@bobfrankston/npmglobalize 1.0.80 → 1.0.82

package/README.md

@@ -224,29 +224,36 @@ Publishing requires being on a branch so commits and tags can be properly tracke
 
 ## Command Reference
 
+<!-- NOTE: Keep this in sync with the --help output in cli.ts printHelp().
+     The README expands on options with examples and context;
+     cli.ts is the concise quick-reference. Update both when adding/changing flags. -->
+
 ### Release Options
 ```
---patch         Bump patch version (default: 1.0.0 → 1.0.1)
---minor         Bump minor version (1.0.0 → 1.1.0)
---major         Bump major version (1.0.0 → 2.0.0)
---nopublish, -np  Just transform, don't publish
---cleanup       Restore file: dependencies from backup
+--patch              Bump patch version (default)
+--minor              Bump minor version
+--major              Bump major version
+--nopublish, -np     Just transform, don't publish
+--cleanup            Restore file: dependencies from backup
+-m, --message <msg>  Custom commit message (forces release even without changes)
 ```
 
 ### Dependency Options
 ```
---update-deps      Update package.json to latest versions (safe: minor/patch)
---update-major     Allow major version updates (breaking changes)
---no-publish-deps, -npd  Skip auto-publishing file: dependencies
---force-publish    Republish dependencies even if version exists
---fix              Run npm audit fix after transformation
---no-fix           Don't run npm audit
+--update-deps, -ud        Update package.json to latest versions (safe: minor/patch)
+--update-major            Allow major version updates (breaking changes)
+--no-publish-deps, -npd   Skip auto-publishing file: dependencies
+--force-publish           Republish dependencies even if version exists
+--fix                     Run npm audit fix after transformation
+--no-fix                  Don't run npm audit
 ```
 
 ### Install Options
 ```
---install, -i   Install globally after publish (Windows)
+--install, -i   Install globally after publish (from registry)
+--link          Install globally via symlink (npm install -g .)
 --wsl           Also install in WSL
+--once          Don't persist flags to .globalize.json5
 ```
 
 ### Mode Options
@@ -258,14 +265,23 @@ Publishing requires being on a branch so commits and tags can be properly tracke
 ### Git/npm Visibility
 ```
 --git private   Make git repo private (default)
---git public    Make git repo public
---npm private   Mark package private (skip publish) (default)
+--git public    Make git repo public (requires confirmation)
+--npm private   Mark npm package private (skip publish) (default)
 --npm public    Publish to npm
 ```
 
+### Workspace Options
+```
+-w, --workspace <pkg>  Filter to specific package (repeatable)
+--no-workspace         Disable workspace mode at a workspace root
+--continue-on-error    Continue if a package fails in workspace mode
+```
+
+Workspace mode is auto-detected when run from a root with `"private": true` and a `workspaces` field.
+
 ### Other Options
 ```
---init          Initialize git/npm if needed (creates .gitignore, .npmignore, 
+--init          Initialize git/npm if needed (creates .gitignore, .npmignore,
                 .gitattributes, and configures git for LF line endings)
 --force         Continue despite git errors
 --dry-run       Preview what would happen
@@ -273,13 +289,41 @@ Publishing requires being on a branch so commits and tags can be properly tracke
 --verbose       Show detailed output
 --conform       Update .gitignore/.npmignore/.gitattributes to best practices
                 and configure git for LF line endings (fixes existing repos)
---asis          Skip ignore file checks
+--asis          Skip ignore file checks (or set "asis": true in .globalize.json5)
 --fix-tags      Automatically fix version/tag mismatches
 --rebase        Automatically rebase if local is behind remote
---help, -h      Show help
---version, -v   Show version
+--show          Show package.json dependency changes
+--package, -pkg Update package.json scripts to use npmglobalize (see below)
+-h, --help      Show help
+-v, --version   Show version
+```
+
+## Using in package.json
+
+You can wire npmglobalize into your package.json `scripts` so that `npm run release` handles publishing:
+
+```json
+{
+  "scripts": {
+    "release": "npmglobalize"
+  }
+}
 ```
 
+The `--package` (`-pkg`) flag does this automatically — it adds a `release` script (renaming any existing `release`/`installer` scripts to `old-release`/`old-installer`):
+
+```bash
+npmglobalize --package       # Sets up "release": "npmglobalize" in package.json
+```
+
+After that, publishing is just:
+```bash
+npm run release              # Same as running npmglobalize directly
+npm run release -- --minor   # Pass flags through
+```
+
+You can also combine it with `.globalize.json5` for persistent options so `npm run release` always uses your preferred settings (install, visibility, etc.).
+
 ## Configuration File
 
 Settings can be saved in `.globalize.json5`:
@@ -375,12 +419,21 @@ npmglobalize -np --update-deps
 # Force republish all dependencies
 npmglobalize --force-publish --update-major
 
-# Release + install on Windows and WSL
+# Release + install on Windows and WSL (from registry)
 npmglobalize --install --wsl
 
+# Release + link on Windows and WSL (symlink)
+npmglobalize --link --wsl
+
 # Restore original file: references
 npmglobalize --cleanup
 
+# Initialize new git repo + release
+npmglobalize --init
+
+# Migrate package.json scripts to use npmglobalize
+npmglobalize --package
+
 # Preview what would happen
 npmglobalize --dry-run --verbose
 ```

package/cli.js

@@ -5,41 +5,10 @@
 import { globalize, globalizeWorkspace, readConfig, readPackageJson, writeConfig, writePackageJson } from './lib.js';
 import fs from 'fs';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import { styleText } from 'util';
 import JSON5 from 'json5';
-// Check if JS files are up-to-date with TS files
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// Check all .ts files in the directory
-const tsFiles = ['lib.ts', 'cli.ts', 'index.ts'];
-const outOfSync = [];
-for (const tsFile of tsFiles) {
-    const tsPath = path.join(__dirname, tsFile);
-    const jsPath = path.join(__dirname, tsFile.replace('.ts', '.js'));
-    if (fs.existsSync(tsPath) && fs.existsSync(jsPath)) {
-        const tsStat = fs.statSync(tsPath);
-        const jsStat = fs.statSync(jsPath);
-        if (jsStat.mtime < tsStat.mtime) {
-            outOfSync.push(tsFile);
-        }
-    }
-}
-if (outOfSync.length > 0 && !process.argv.includes('--force')) {
-    console.error('\n' + styleText('red', '❌ Build check failed:'));
-    console.error(styleText('red', `   ${outOfSync.length} file(s) need compilation in ${__dirname}:`));
-    outOfSync.forEach(f => {
-        const tsPath = path.join(__dirname, f);
-        const jsPath = path.join(__dirname, f.replace('.ts', '.js'));
-        const tsMtime = fs.statSync(tsPath).mtime;
-        const jsMtime = fs.statSync(jsPath).mtime;
-        const fmt = (d) => d.toLocaleString();
-        console.error(styleText('red', `     - ${tsPath}`));
-        console.error(styleText('red', `       .ts: ${fmt(tsMtime)}  .js: ${fmt(jsMtime)}`));
-    });
-    console.error('\n' + styleText('yellow', '   Please run: tsc'));
-    console.error(styleText('yellow', '   Or use --force to skip this check') + '\n');
-    process.exit(1);
-}
+// npmglobalize install directory (for --version)
+const __dirname = import.meta.dirname;
 function printHelp() {
     console.log(`
 npmglobalize - Transform file: dependencies to npm versions for publishing
@@ -68,6 +37,7 @@ Install Options:
   --install, -i    Global install after publish (from registry)
   --link           Global install via symlink (npm install -g .)
   --wsl            Also install globally in WSL
+  --once           Don't persist flags to .globalize.json5
 
 Mode Options:
   --files         Keep file: paths after publish (default)
@@ -300,6 +270,9 @@ function parseArgs(args) {
             case '-pkg':
                 options.package = true;
                 break;
+            case '--once':
+                options.once = true;
+                break;
             default:
                 if (arg.startsWith('-')) {
                     unrecognized.push(arg);
@@ -329,52 +302,11 @@ export async function main() {
         process.exit(0);
     }
     if (cliOptions.version) {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
         const pkgPath = path.join(__dirname, 'package.json');
         const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
         console.log(pkg.version);
         process.exit(0);
     }
-    // Check if TypeScript files are compiled (unless --force or --help/--version)
-    if (!cliOptions.force && !cliOptions.help && !cliOptions.version) {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
-        // Check for noEmit in tsconfig.json
-        let noEmit = false;
-        try {
-            const tsconfigPath = path.join(__dirname, 'tsconfig.json');
-            const content = fs.readFileSync(tsconfigPath, 'utf-8');
-            const tsconfig = JSON5.parse(content);
-            noEmit = tsconfig.compilerOptions?.noEmit === true;
-        }
-        catch (error) {
-            // If we can't read tsconfig, assume we need to check
-        }
-        if (!noEmit) {
-            // Check if this .js file is older than its .ts source
-            const jsFile = __filename;
-            const tsFile = jsFile.replace(/\.js$/, '.ts');
-            if (fs.existsSync(tsFile)) {
-                if (!fs.existsSync(jsFile)) {
-                    console.error('\n❌ Error: TypeScript files not compiled');
-                    console.error(`Missing: ${path.basename(jsFile)}`);
-                    console.error('\nPlease run: npm run build');
-                    console.error('Or use --force to skip this check\n');
-                    process.exit(1);
-                }
-                const tsStat = fs.statSync(tsFile);
-                const jsStat = fs.statSync(jsFile);
-                if (jsStat.mtime < tsStat.mtime) {
-                    console.error('\n❌ Error: TypeScript files not compiled');
-                    console.error(`${path.basename(jsFile)} is older than ${path.basename(tsFile)}`);
-                    console.error('\nPlease run: npm run build');
-                    console.error('Or use --force to skip this check\n');
-                    process.exit(1);
-                }
-            }
-        }
-    }
     if (cliOptions.error) {
         console.error(`Error: ${cliOptions.error}`);
         console.error('Run with --help for usage.');
@@ -393,6 +325,50 @@ export async function main() {
             process.exit(1);
         }
     }
+    // Check if TypeScript files in target project are compiled
+    if (!cliOptions.force) {
+        let noEmit = false;
+        try {
+            const tsconfigPath = path.join(cwd, 'tsconfig.json');
+            const content = fs.readFileSync(tsconfigPath, 'utf-8');
+            const tsconfig = JSON5.parse(content);
+            noEmit = tsconfig.compilerOptions?.noEmit === true;
+        }
+        catch (error) {
+            // No tsconfig or can't parse — skip check
+            noEmit = true;
+        }
+        if (!noEmit) {
+            const outOfSync = [];
+            const jsFiles = fs.readdirSync(cwd).filter(f => f.endsWith('.js') && !f.endsWith('.min.js'));
+            for (const jsFile of jsFiles) {
+                const tsFile = jsFile.replace(/\.js$/, '.ts');
+                const tsPath = path.join(cwd, tsFile);
+                const jsPath = path.join(cwd, jsFile);
+                if (fs.existsSync(tsPath)) {
+                    const tsStat = fs.statSync(tsPath);
+                    const jsStat = fs.statSync(jsPath);
+                    if (jsStat.mtime < tsStat.mtime) {
+                        outOfSync.push(tsFile);
+                    }
+                }
+            }
+            if (outOfSync.length > 0) {
+                console.error('\n' + styleText('red', '❌ Build check failed:'));
+                console.error(styleText('red', `   ${outOfSync.length} file(s) need compilation in ${cwd}:`));
+                outOfSync.forEach(f => {
+                    const tsPath = path.join(cwd, f);
+                    const jsPath = path.join(cwd, f.replace('.ts', '.js'));
+                    const fmt = (d) => d.toLocaleString();
+                    console.error(styleText('red', `     - ${f}`));
+                    console.error(styleText('red', `       .ts: ${fmt(fs.statSync(tsPath).mtime)}  .js: ${fmt(fs.statSync(jsPath).mtime)}`));
+                });
+                console.error('\n' + styleText('yellow', '   Please run: tsc'));
+                console.error(styleText('yellow', '   Or use --force to skip this check') + '\n');
+                process.exit(1);
+            }
+        }
+    }
     // Handle --package: update scripts in target package.json
     if (cliOptions.package) {
         const pkg = readPackageJson(cwd);
@@ -419,7 +395,7 @@ export async function main() {
     const configOptions = readConfig(cwd);
     const options = { ...configOptions, ...cliOptions };
     // Persist explicitly set CLI flags to .globalize.json5
-    if (cliOptions.explicitKeys.size > 0) {
+    if (cliOptions.explicitKeys.size > 0 && !cliOptions.once) {
         const persistable = { ...configOptions };
         for (const key of cliOptions.explicitKeys) {
             persistable[key] = options[key];

package/lib.d.ts

@@ -69,6 +69,8 @@ export interface GlobalizeOptions {
     continueOnError?: boolean;
     /** Update package.json scripts to use npmglobalize */
     package?: boolean;
+    /** Don't persist CLI flags to .globalize.json5 */
+    once?: boolean;
     /** Internal: signals this call is from workspace orchestrator */
     _fromWorkspace?: boolean;
 }

package/lib.js

@@ -110,7 +110,7 @@ export function writeConfig(dir, config, explicitKeys) {
     const existing = readConfig(dir);
     // Filter out temporary flags and default values (unless explicitly set)
     const filtered = {};
-    const omitKeys = new Set(['noPublish', 'cleanup', 'init', 'dryRun', 'message', 'conform', 'asis', 'help', 'error', 'updateDeps', 'updateMajor', 'publishDeps', 'forcePublish']);
+    const omitKeys = new Set(['noPublish', 'cleanup', 'init', 'dryRun', 'message', 'conform', 'asis', 'help', 'error', 'updateDeps', 'updateMajor', 'publishDeps', 'forcePublish', 'once']);
     for (const [key, value] of Object.entries(config)) {
         if (omitKeys.has(key))
             continue;
@@ -719,13 +719,33 @@ export function fixVersionTagMismatch(cwd, pkg, verbose = false) {
     }
     return deletedAny;
 }
+/** Wait for a package version to appear on the npm registry */
+function waitForNpmVersion(pkgName, version, maxWaitMs = 60000) {
+    const interval = 3000;
+    const maxAttempts = Math.ceil(maxWaitMs / interval);
+    process.stdout.write(`Waiting for ${pkgName}@${version} on npm registry`);
+    for (let i = 0; i < maxAttempts; i++) {
+        const result = spawnSync('npm', ['view', `${pkgName}@${version}`, 'version'], {
+            shell: process.platform === 'win32',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            encoding: 'utf-8'
+        });
+        if (result.status === 0 && result.stdout?.trim() === version) {
+            process.stdout.write(' ready\n');
+            return true;
+        }
+        process.stdout.write('.');
+        spawnSync(process.platform === 'win32' ? 'timeout' : 'sleep', process.platform === 'win32' ? ['/t', '3', '/nobreak'] : ['3'], { stdio: 'pipe', shell: process.platform === 'win32' });
+    }
+    process.stdout.write(' timed out\n');
+    return false;
+}
 /** Run a command and return success status */
 export function runCommand(cmd, args, options = {}) {
     const { silent = false, cwd } = options;
     try {
-        // Only use shell:true for npm commands which need it on Windows
-        // Git and other commands work fine without shell
-        const needsShell = cmd === 'npm' || cmd === 'npm.cmd';
+        // Use shell:true for npm/gh commands which need it on Windows
+        const needsShell = cmd === 'npm' || cmd === 'npm.cmd' || cmd === 'gh';
         // Debug: log the command being executed
         if (!silent) {
             console.log(colors.dim(`[DEBUG] Running: ${cmd} ${args.join(' ')}`));
@@ -782,13 +802,13 @@ function getGitHubRepo(pkg) {
 }
 /** 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 needsShell = cmd === 'npm' || cmd === 'npm.cmd' || cmd === 'gh';
     const result = spawnSync(cmd, args, {
         encoding: 'utf-8',
         stdio: 'pipe',
-        cwd: captureOptions.cwd,
-        shell: false
+        cwd: options.cwd,
+        env: process.env,
+        shell: needsShell
     });
     const stdout = result.stdout || '';
     const stderr = result.stderr || '';
@@ -2053,6 +2073,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                     }
                 }
                 else if (install) {
+                    waitForNpmVersion(pkgName, pkgVersion);
                     console.log(`Installing ${pkgName}@${pkgVersion} globally from registry...`);
                     const registryInstallResult = runCommand('npm', ['install', '-g', `${pkgName}@${pkgVersion}`], { cwd, silent: false });
                     if (registryInstallResult.success) {
@@ -2065,6 +2086,8 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                 }
                 if (wsl) {
                     const wslArgs = link ? ['npm', 'install', '-g', '.'] : ['npm', 'install', '-g', `${pkgName}@${pkgVersion}`];
+                    if (!link && !install)
+                        waitForNpmVersion(pkgName, pkgVersion);
                     console.log(`Installing ${pkgName} in WSL${link ? ' (link)' : ' from registry'}...`);
                     const wslInstallResult = runCommand('wsl', wslArgs, { cwd, silent: false });
                     if (wslInstallResult.success) {
@@ -2510,6 +2533,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         else if (install) {
             console.log(`Installing globally from registry: ${pkgName}@${pkgVersion}...`);
             if (!dryRun) {
+                waitForNpmVersion(pkgName, pkgVersion);
                 const installResult = runCommand('npm', ['install', '-g', `${pkgName}@${pkgVersion}`], { cwd, silent: false });
                 if (installResult.success) {
                     console.log(colors.green(`✓ Installed globally: ${pkgName}@${pkgVersion}`));
@@ -2525,6 +2549,8 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         }
         if (wsl) {
             const wslArgs = link ? ['npm', 'install', '-g', '.'] : ['npm', 'install', '-g', `${pkgName}@${pkgVersion}`];
+            if (!link && !install)
+                waitForNpmVersion(pkgName, pkgVersion);
             console.log(`Installing in WSL${link ? ' (link)' : ' from registry'}: ${pkgName}@${pkgVersion}...`);
             if (!dryRun) {
                 const wslResult = runCommand('wsl', wslArgs, { cwd, silent: false });

package/package.json

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