@bobfrankston/npmglobalize 1.0.12

package/lib.js

@@ -0,0 +1,867 @@
+/**
+ * npmglobalize - Transform file: dependencies to npm versions for publishing
+ */
+import fs from 'fs';
+import path from 'path';
+import { execSync, spawnSync } from 'child_process';
+import readline from 'readline';
+import libversion from 'libnpmversion';
+/** 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`,
+};
+const DEP_KEYS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+/** Read and parse package.json from a directory */
+export function readPackageJson(dir) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        throw new Error(`package.json not found: ${pkgPath}`);
+    }
+    return JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+}
+/** Read .globalize.jsonc config file */
+export function readConfig(dir) {
+    const configPath = path.join(dir, '.globalize.jsonc');
+    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);
+    }
+    catch (error) {
+        console.warn(`Warning: Could not parse .globalize.jsonc config: ${error.message}`);
+        return {};
+    }
+}
+/** Write .globalize.jsonc config file */
+export function writeConfig(dir, config) {
+    const configPath = path.join(dir, '.globalize.jsonc');
+    // Build content with comments
+    const lines = [
+        '{',
+        '  // Only set options that differ from defaults',
+        '  // Defaults: bump=patch, files=true, quiet=true, gitVisibility=private, npmVisibility=public',
+        ''
+    ];
+    // 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"');
+    lines.push('}');
+    fs.writeFileSync(configPath, lines.join('\n') + '\n');
+}
+/** Write package.json to a directory */
+export function writePackageJson(dir, pkg) {
+    const pkgPath = path.join(dir, 'package.json');
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+}
+/** Resolve a file: path to absolute path */
+export function resolveFilePath(fileRef, baseDir) {
+    const relativePath = fileRef.replace(/^file:/, '');
+    return path.resolve(baseDir, relativePath);
+}
+/** Check if a dependency value is a file: reference */
+export function isFileRef(value) {
+    return typeof value === 'string' && value.startsWith('file:');
+}
+/** Get all file: dependencies from package.json */
+export function getFileRefs(pkg) {
+    const refs = new Map();
+    for (const key of DEP_KEYS) {
+        if (!pkg[key])
+            continue;
+        for (const [name, value] of Object.entries(pkg[key])) {
+            if (isFileRef(value)) {
+                refs.set(`${key}:${name}`, { key, name, value: value });
+            }
+        }
+    }
+    return refs;
+}
+/** Transform file: dependencies to npm versions */
+export function transformDeps(pkg, baseDir, verbose = false) {
+    let transformed = false;
+    for (const key of DEP_KEYS) {
+        if (!pkg[key])
+            continue;
+        const dotKey = '.' + key;
+        const hasFileRefs = Object.values(pkg[key]).some(v => isFileRef(v));
+        if (!hasFileRefs)
+            continue;
+        // If .dependencies already exists, sync any new file: refs to it
+        if (pkg[dotKey]) {
+            for (const [name, value] of Object.entries(pkg[key])) {
+                if (isFileRef(value)) {
+                    pkg[dotKey][name] = value;
+                }
+            }
+        }
+        else {
+            // Backup original
+            pkg[dotKey] = { ...pkg[key] };
+        }
+        // Transform file: refs to npm versions
+        for (const [name, value] of Object.entries(pkg[key])) {
+            if (isFileRef(value)) {
+                const targetPath = resolveFilePath(value, baseDir);
+                try {
+                    const targetPkg = readPackageJson(targetPath);
+                    const npmVersion = '^' + targetPkg.version;
+                    pkg[key][name] = npmVersion;
+                    if (verbose) {
+                        console.log(`  ${name}: ${value} -> ${npmVersion}`);
+                    }
+                    transformed = true;
+                }
+                catch (error) {
+                    throw new Error(`Failed to resolve ${name} at ${targetPath}: ${error.message}`);
+                }
+            }
+        }
+    }
+    return transformed;
+}
+/** Restore file: dependencies from .dependencies */
+export function restoreDeps(pkg, verbose = false) {
+    let restored = false;
+    for (const key of DEP_KEYS) {
+        const dotKey = '.' + key;
+        if (pkg[dotKey]) {
+            pkg[key] = pkg[dotKey];
+            delete pkg[dotKey];
+            restored = true;
+            if (verbose) {
+                console.log(`  Restored ${key} from ${dotKey}`);
+            }
+        }
+    }
+    return restored;
+}
+/** Check if .dependencies exist (already transformed) */
+export function hasBackup(pkg) {
+    return DEP_KEYS.some(key => pkg['.' + key]);
+}
+/** Run a command and return success status */
+export function runCommand(cmd, args, options = {}) {
+    const { silent = false, cwd } = 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
+        });
+        // 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
+        if (!silent) {
+            return {
+                success: result.status === 0,
+                output: '',
+                stderr: ''
+            };
+        }
+        const output = result.stdout || '';
+        const stderr = result.stderr || '';
+        return {
+            success: result.status === 0,
+            output: output,
+            stderr: stderr
+        };
+    }
+    catch (error) {
+        return { success: false, output: '', stderr: error.message };
+    }
+}
+/** Run a command and throw on failure */
+export function runCommandOrThrow(cmd, args, options = {}) {
+    // For commands that should throw, we need to capture output, so use silent=true
+    const captureOptions = { ...options, silent: true };
+    const result = spawnSync(cmd, args, {
+        encoding: 'utf-8',
+        stdio: 'pipe',
+        cwd: captureOptions.cwd,
+        shell: false
+    });
+    const stdout = result.stdout || '';
+    const stderr = result.stderr || '';
+    const output = stdout + stderr;
+    if (result.status !== 0) {
+        // Show the error output
+        if (stderr.trim()) {
+            console.error(colors.red(stderr.trim()));
+        }
+        if (stdout.trim()) {
+            console.log(stdout.trim());
+        }
+        throw new Error(`Command failed with exit code ${result.status}: ${cmd} ${args.join(' ')}`);
+    }
+    return output;
+}
+export function getGitStatus(cwd) {
+    const status = {
+        isRepo: false,
+        hasRemote: false,
+        hasUncommitted: false,
+        hasUnpushed: false,
+        hasMergeConflict: false,
+        isDetachedHead: false,
+        currentBranch: '',
+        remoteBranch: ''
+    };
+    // Check if git repo
+    const gitDir = path.join(cwd, '.git');
+    if (!fs.existsSync(gitDir)) {
+        return status;
+    }
+    status.isRepo = true;
+    // Check for merge conflicts
+    const mergeHead = path.join(gitDir, 'MERGE_HEAD');
+    status.hasMergeConflict = fs.existsSync(mergeHead);
+    // Get branch info
+    try {
+        const branch = execSync('git rev-parse --abbrev-ref HEAD 2>nul', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        status.currentBranch = branch;
+        status.isDetachedHead = branch === 'HEAD';
+    }
+    catch (error) {
+        // Ignore - might be no commits yet
+    }
+    // Check for remote
+    try {
+        const remote = execSync('git remote 2>nul', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        status.hasRemote = remote.length > 0;
+    }
+    catch (error) {
+        // Ignore
+    }
+    // Check for uncommitted changes
+    try {
+        const statusOutput = execSync('git status --porcelain 2>nul', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
+        status.hasUncommitted = statusOutput.trim().length > 0;
+    }
+    catch (error) {
+        // Ignore
+    }
+    // Check for unpushed commits
+    if (status.hasRemote && !status.isDetachedHead && status.currentBranch) {
+        try {
+            const unpushed = execSync(`git log origin/${status.currentBranch}..HEAD --oneline 2>nul`, {
+                cwd,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore']
+            }).trim();
+            status.hasUnpushed = unpushed.length > 0;
+        }
+        catch (error) {
+            // Ignore - might not have tracking branch
+        }
+    }
+    return status;
+}
+/** Validate package.json for release */
+export function validatePackageJson(pkg) {
+    const errors = [];
+    const warnings = [];
+    if (!pkg.repository) {
+        errors.push('Missing repository field - required for npm packages');
+    }
+    if (!pkg.description) {
+        warnings.push('Missing description field');
+    }
+    if (!pkg.name) {
+        errors.push('Missing name field');
+    }
+    if (!pkg.version) {
+        errors.push('Missing version field');
+    }
+    // Print warnings
+    for (const w of warnings) {
+        console.log(`  Warning: ${w}`);
+    }
+    return errors;
+}
+/** Prompt user for confirmation */
+export async function confirm(message, defaultYes = false) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const suffix = defaultYes ? '[Y/n]' : '[y/N]';
+    return new Promise((resolve) => {
+        rl.question(`${message} ${suffix} `, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            if (a === '') {
+                resolve(defaultYes);
+            }
+            else {
+                resolve(a === 'y' || a === 'yes');
+            }
+        });
+    });
+}
+/** Check npm authentication status */
+function checkNpmAuth() {
+    try {
+        // Use shell:true on Windows for better compatibility
+        const result = spawnSync('npm', ['whoami'], {
+            encoding: 'utf-8',
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        if (result.status === 0 && result.stdout && result.stdout.trim()) {
+            return { authenticated: true, username: result.stdout.trim() };
+        }
+        // Parse error message to determine the issue
+        const stderr = (result.stderr || '').toLowerCase();
+        if (stderr.includes('code eneedauth') || stderr.includes('not logged in')) {
+            return { authenticated: false, error: 'not logged in' };
+        }
+        else if (stderr.includes('token') && (stderr.includes('expired') || stderr.includes('revoked'))) {
+            return { authenticated: false, error: 'token expired' };
+        }
+        else if (stderr) {
+            return { authenticated: false, error: 'unknown auth error' };
+        }
+        else {
+            // npm whoami failed but with no stderr - likely auth issue
+            return { authenticated: false, error: 'not logged in' };
+        }
+    }
+    catch (error) {
+        return { authenticated: false, error: error.message };
+    }
+}
+/** Get authentication setup instructions */
+function getAuthInstructions() {
+    const npmrcPath = path.join(process.env.USERPROFILE || process.env.HOME || '~', '.npmrc');
+    return `
+Authentication Options:
+
+1. ${colors.yellow('Create a Granular Access Token')} (recommended):
+   - Go to: https://www.npmjs.com/settings/[username]/tokens
+   - Click "Generate New Token" → "Granular Access Token"
+   - Set permissions: ${colors.green('Read and write')} for packages
+   - Enable: ${colors.green('Bypass 2FA requirement')} (if available)
+   - Copy the token and save it securely
+
+2. ${colors.yellow('Set token via environment variable')}:
+   - Set: ${colors.green('NPM_TOKEN=npm_xxx...')}
+   - Or run: ${colors.green('$env:NPM_TOKEN="npm_xxx..."')} (PowerShell)
+
+3. ${colors.yellow('Set token in .npmrc')}:
+   - Edit: ${colors.green(npmrcPath)}
+   - Add: ${colors.green('//registry.npmjs.org/:_authToken=npm_xxx...')}
+
+4. ${colors.yellow('Use classic login')} (may require 2FA):
+   - Run: ${colors.green('npm login')}
+   - Follow interactive prompts
+
+Note: npm now requires either 2FA or a granular token with bypass enabled.
+`;
+}
+/** Ensure .gitignore exists and includes node_modules */
+function ensureGitignore(cwd) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    let content = '';
+    let needsUpdate = false;
+    // Read existing .gitignore if it exists
+    if (fs.existsSync(gitignorePath)) {
+        content = fs.readFileSync(gitignorePath, 'utf-8');
+        // Check if node_modules is already ignored
+        const lines = content.split('\n').map(l => l.trim());
+        const hasNodeModules = lines.some(line => line === 'node_modules' ||
+            line === 'node_modules/' ||
+            line === '/node_modules' ||
+            line === '/node_modules/');
+        if (!hasNodeModules) {
+            console.log(colors.yellow('  Warning: node_modules not found in .gitignore, adding it...'));
+            needsUpdate = true;
+        }
+    }
+    else {
+        console.log('  Creating .gitignore...');
+        needsUpdate = true;
+    }
+    // Update .gitignore if needed
+    if (needsUpdate) {
+        if (!content || content.trim() === '') {
+            // Create new .gitignore with common patterns
+            content = `node_modules/
+.env*
+*cert*/
+*certs*/
+*.pem
+*.key
+*.p12
+*.pfx
+configuration.json
+token
+tokens
+*.token
+cruft/
+prev/
+tests/
+*.log
+.DS_Store
+Thumbs.db
+`;
+        }
+        else {
+            // Add node_modules to existing .gitignore
+            if (!content.endsWith('\n')) {
+                content += '\n';
+            }
+            content = 'node_modules/\n' + content;
+        }
+        fs.writeFileSync(gitignorePath, content);
+        console.log(colors.green('  ✓ .gitignore updated'));
+    }
+}
+/** Initialize git repository */
+export async function initGit(cwd, visibility, dryRun) {
+    const pkg = readPackageJson(cwd);
+    const repoName = pkg.name.replace(/^@[^/]+\//, ''); // Remove scope
+    console.log('Initializing git repository...');
+    // Explicit visibility confirmation
+    if (visibility === 'public') {
+        const ok = await confirm('Create PUBLIC git repo - anyone can see your code. Continue?', false);
+        if (!ok) {
+            console.log('Aborted.');
+            return false;
+        }
+    }
+    else {
+        console.log(`Creating PRIVATE git repo '${repoName}' (default)...`);
+    }
+    if (dryRun) {
+        console.log('  [dry-run] Would run: git init');
+        console.log(`  [dry-run] Would run: gh repo create ${repoName} --${visibility} --source=. --push`);
+        return true;
+    }
+    // Ensure .gitignore exists and includes node_modules
+    ensureGitignore(cwd);
+    // git init
+    runCommandOrThrow('git', ['init'], { cwd });
+    runCommandOrThrow('git', ['add', '-A'], { cwd });
+    runCommandOrThrow('git', ['commit', '-m', 'Initial commit'], { cwd });
+    // Create GitHub repo
+    const visFlag = visibility === 'private' ? '--private' : '--public';
+    runCommandOrThrow('gh', ['repo', 'create', repoName, visFlag, '--source=.', '--push'], { cwd });
+    // Update package.json with repository field
+    try {
+        const remoteUrl = execSync('git remote get-url origin', { cwd, encoding: 'utf-8' }).trim();
+        pkg.repository = {
+            type: 'git',
+            url: remoteUrl
+        };
+        writePackageJson(cwd, pkg);
+        console.log('  Updated package.json with repository field');
+    }
+    catch (error) {
+        console.log('  Warning: Could not update repository field');
+    }
+    return true;
+}
+/** 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;
+    // Handle cleanup mode
+    if (cleanup) {
+        console.log('Restoring dependencies from backup...');
+        const pkg = readPackageJson(cwd);
+        if (restoreDeps(pkg, verbose)) {
+            if (!dryRun) {
+                writePackageJson(cwd, pkg);
+            }
+            console.log('Dependencies restored.');
+        }
+        else {
+            console.log('No backup found - nothing to restore.');
+        }
+        return true;
+    }
+    // Check npm authentication early (unless dry-run or apply-only)
+    if (!dryRun && !applyOnly) {
+        const authStatus = checkNpmAuth();
+        if (!authStatus.authenticated) {
+            console.error(colors.red('\n✗ npm authentication required'));
+            console.error('');
+            if (authStatus.error === 'token expired') {
+                console.error('Your npm access token has expired or been revoked.');
+                console.error('');
+                console.error('To fix this, run:');
+                console.error(colors.yellow('  npm logout'));
+                console.error(colors.yellow('  npm login'));
+            }
+            else if (authStatus.error === 'not logged in') {
+                console.error('You are not logged in to npm.');
+                console.error('');
+                console.error('To fix this, run:');
+                console.error(colors.yellow('  npm login'));
+            }
+            else {
+                console.error(`Authentication error: ${authStatus.error}`);
+                console.error('');
+                console.error('Try running:');
+                console.error(colors.yellow('  npm whoami'));
+            }
+            console.error('');
+            console.error('After logging in, try running this command again.');
+            return false;
+        }
+        if (verbose) {
+            console.log(colors.green(`✓ Authenticated as ${authStatus.username}`));
+        }
+    }
+    // Check git status
+    const gitStatus = getGitStatus(cwd);
+    // Handle init mode
+    if (!gitStatus.isRepo) {
+        console.log('No git repository found.');
+        if (dryRun) {
+            console.log('  [dry-run] Would initialize git repository');
+        }
+        else if (!init) {
+            const ok = await confirm('Initialize git repository?', true);
+            if (!ok) {
+                console.log('Aborted. Run with --init to initialize.');
+                return false;
+            }
+            const success = await initGit(cwd, gitVisibility, dryRun);
+            if (!success)
+                return false;
+        }
+        else {
+            const success = await initGit(cwd, gitVisibility, dryRun);
+            if (!success)
+                return false;
+        }
+    }
+    else if (init && !gitStatus.hasRemote) {
+        // Git repo exists but no remote - create GitHub repo
+        const success = await initGit(cwd, gitVisibility, dryRun);
+        if (!success)
+            return false;
+    }
+    // Re-check git status after potential init
+    const currentGitStatus = getGitStatus(cwd);
+    // Validate git state
+    if (currentGitStatus.hasMergeConflict) {
+        console.error(colors.red('ERROR: Merge conflict detected. Resolve before releasing.'));
+        return false;
+    }
+    if (currentGitStatus.isDetachedHead && !force) {
+        console.error(colors.red('ERROR: Detached HEAD state. Use --force to continue anyway.'));
+        return false;
+    }
+    if (currentGitStatus.isDetachedHead && force) {
+        console.log(colors.yellow('Warning: Detached HEAD state - continuing with --force'));
+    }
+    // Read package.json
+    const pkg = readPackageJson(cwd);
+    // Auto-add repository field if git exists but field is missing
+    if (currentGitStatus.isRepo && currentGitStatus.hasRemote && !pkg.repository) {
+        try {
+            const remoteUrl = execSync('git remote get-url origin', { cwd, encoding: 'utf-8' }).trim();
+            pkg.repository = {
+                type: 'git',
+                url: remoteUrl
+            };
+            writePackageJson(cwd, pkg);
+            console.log('Added repository field from git remote.');
+        }
+        catch (error) {
+            // Ignore - will be caught by validation
+        }
+    }
+    // Validate package.json
+    console.log('Validating package.json...');
+    const errors = validatePackageJson(pkg);
+    if (errors.length > 0) {
+        // Check if missing repository and no remote - suggest init
+        if (!pkg.repository && !currentGitStatus.hasRemote) {
+            console.error(colors.red('ERROR: Missing repository field and no git remote configured.'));
+            console.error(colors.red('Run with --init to set up GitHub repository.'));
+            return false;
+        }
+        for (const e of errors) {
+            console.error(colors.red(`  ERROR: ${e}`));
+        }
+        if (!force) {
+            return false;
+        }
+        console.log(colors.yellow('Continuing with --force despite errors...'));
+    }
+    // Check npm visibility - explicit confirmation
+    if (npmVisibility === 'private') {
+        if (!pkg.private) {
+            const ok = await confirm('Mark npm package PRIVATE - will not publish to npm. Continue?', false);
+            if (!ok) {
+                console.log('Aborted.');
+                return false;
+            }
+            pkg.private = true;
+        }
+    }
+    else {
+        // Default is public - just inform
+        console.log(`Will publish '${pkg.name}' to PUBLIC npm registry (default).`);
+    }
+    // Transform dependencies
+    console.log('Transforming file: dependencies...');
+    const alreadyTransformed = hasBackup(pkg);
+    if (alreadyTransformed) {
+        console.log('  Already transformed (found .dependencies)');
+    }
+    const transformed = transformDeps(pkg, cwd, verbose);
+    if (transformed) {
+        console.log('  Dependencies transformed.');
+        if (!dryRun) {
+            writePackageJson(cwd, pkg);
+        }
+    }
+    else if (!alreadyTransformed) {
+        console.log('  No file: dependencies found.');
+    }
+    if (applyOnly) {
+        console.log('Transform complete (--apply mode).');
+        return true;
+    }
+    // Skip if private
+    if (pkg.private) {
+        console.log('Package is private - skipping npm publish.');
+        return true;
+    }
+    // Check if there are changes to commit or a custom message
+    if (!currentGitStatus.hasUncommitted && !message) {
+        console.log('');
+        console.log('No changes to commit and no custom message specified.');
+        console.log('Nothing to release. Use -m "message" to force a release.');
+        return true;
+    }
+    // Ensure node_modules is in .gitignore before any git operations
+    if (currentGitStatus.isRepo && !dryRun) {
+        ensureGitignore(cwd);
+    }
+    // Git operations
+    if (currentGitStatus.hasUncommitted) {
+        const commitMsg = message || 'Pre-release commit';
+        console.log(`Committing changes: ${commitMsg}`);
+        if (!dryRun) {
+            runCommand('git', ['add', '-A'], { cwd });
+            runCommand('git', ['commit', '-m', commitMsg], { cwd });
+        }
+        else {
+            console.log('  [dry-run] Would commit changes');
+        }
+    }
+    // Version bump
+    console.log(`Bumping version (${bump})...`);
+    if (!dryRun) {
+        try {
+            // Use libnpmversion - it will create commit and tag automatically
+            const newVersion = await libversion(bump, {
+                path: cwd
+            });
+            console.log(colors.green(`Version bumped to ${newVersion}`));
+        }
+        catch (error) {
+            console.error(colors.red('ERROR: Version bump failed:'), error.message);
+            if (!force) {
+                return false;
+            }
+            console.log(colors.yellow('Continuing with --force...'));
+        }
+    }
+    else {
+        console.log(`  [dry-run] Would run: npm version ${bump}`);
+    }
+    // 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('');
+            }
+            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('');
+            }
+            else if (errorOutput.includes('e402') || errorOutput.includes('payment required')) {
+                console.error(colors.yellow('Payment required for private packages.'));
+                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('');
+            }
+            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'));
+            }
+            if (transformed) {
+                console.log('Run --cleanup to restore file: dependencies');
+            }
+            return false;
+        }
+        console.log(colors.green('✓ Published to npm'));
+    }
+    else {
+        console.log(`  [dry-run] Would run: npm publish ${quiet ? '--quiet' : ''}`);
+    }
+    // Push to git
+    if (currentGitStatus.hasRemote) {
+        console.log('Pushing to git...');
+        if (!dryRun) {
+            runCommand('git', ['push'], { cwd });
+            runCommand('git', ['push', '--tags'], { cwd });
+        }
+        else {
+            console.log('  [dry-run] Would push to git');
+        }
+    }
+    // Global install
+    const pkgName = pkg.name;
+    if (install) {
+        console.log(`Installing globally: ${pkgName}...`);
+        if (!dryRun) {
+            runCommand('npm', ['install', '-g', pkgName], { cwd });
+        }
+        else {
+            console.log(`  [dry-run] Would run: npm install -g ${pkgName}`);
+        }
+    }
+    if (wsl) {
+        console.log(`Installing in WSL: ${pkgName}...`);
+        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?)');
+            }
+        }
+        else {
+            console.log(`  [dry-run] Would run: wsl npm install -g ${pkgName}`);
+        }
+    }
+    // Finalize - restore file: paths if --files mode (default)
+    if (files && transformed) {
+        console.log('Restoring file: dependencies (--files mode)...');
+        const finalPkg = readPackageJson(cwd);
+        restoreDeps(finalPkg, verbose);
+        if (!dryRun) {
+            writePackageJson(cwd, finalPkg);
+            // Commit the restore
+            runCommand('git', ['add', 'package.json'], { cwd });
+            runCommand('git', ['commit', '-m', 'Restore file: dependencies'], { cwd });
+            if (currentGitStatus.hasRemote) {
+                runCommand('git', ['push'], { cwd });
+            }
+        }
+    }
+    else if (!files) {
+        console.log('Keeping npm versions (--nofiles mode).');
+    }
+    console.log('Done!');
+    // Print summary
+    console.log('');
+    console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log(colors.green('✓ Release Summary'));
+    console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    const finalPkg = readPackageJson(cwd);
+    console.log(`  Package: ${colors.green(finalPkg.name)}`);
+    console.log(`  Version: ${colors.green('v' + finalPkg.version)}`);
+    console.log(`  Published: ${colors.green('✓')}`);
+    console.log(`  Git pushed: ${colors.green('✓')}`);
+    if (install) {
+        console.log(`  Installed globally: ${colors.green('✓')}`);
+    }
+    if (wsl) {
+        console.log(`  Installed in WSL: ${colors.green('✓')}`);
+    }
+    if (files && transformed) {
+        console.log(`  Restored file: deps: ${colors.green('✓')}`);
+    }
+    console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log('');
+    console.log(`Run: ${colors.green(finalPkg.name.includes('/') ? finalPkg.name.split('/')[1] : finalPkg.name)}`);
+    console.log('');
+    return true;
+}
+export default {
+    globalize,
+    transformDeps,
+    restoreDeps,
+    readPackageJson,
+    writePackageJson,
+    getGitStatus,
+    validatePackageJson,
+    confirm,
+    initGit
+};
+//# sourceMappingURL=lib.js.map