@bobfrankston/npmglobalize 1.0.47 → 1.0.49

package/README.md

@@ -259,8 +259,8 @@ Publishing requires being on a branch so commits and tags can be properly tracke
 ```
 --git private   Make git repo private (default)
 --git public    Make git repo public
---npm private   Mark package private (skip publish)
---npm public    Publish to npm (default)
+--npm private   Mark package private (skip publish) (default)
+--npm public    Publish to npm
 ```
 
 ### Other Options

package/cli.js

@@ -58,8 +58,8 @@ Mode Options:
 Git/npm Visibility:
   --git private   Make git repo private (default)
   --git public    Make git repo public (requires confirmation)
-  --npm private   Mark npm package private (skip publish)
-  --npm public    Publish to npm (default)
+  --npm private   Mark npm package private (skip publish) (default)
+  --npm public    Publish to npm
 
 Other Options:
   --init          Initialize git/npm if needed
@@ -328,7 +328,7 @@ export async function main() {
     const configOptions = readConfig(cwd);
     const options = { ...configOptions, ...cliOptions };
     try {
-        const success = await globalize(cwd, options);
+        const success = await globalize(cwd, options, configOptions);
         process.exit(success ? 0 : 1);
     }
     catch (error) {

package/lib.d.ts

@@ -70,6 +70,8 @@ export declare function getLatestVersion(packageName: string): string | null;
 export declare function checkVersionExists(packageName: string, version: string): boolean;
 /** Check if a package exists on npm (any version) */
 export declare function checkPackageExists(packageName: string): boolean;
+/** Check npm package access level (public/restricted/null if not published) */
+export declare function checkNpmAccess(packageName: string): 'public' | 'restricted' | null;
 /** Update existing npm dependencies to latest versions */
 export declare function updateNpmDeps(pkg: any, verbose?: boolean, allowMajor?: boolean): {
     updated: boolean;
@@ -158,7 +160,7 @@ export declare function runNpmAudit(cwd: string, fix?: boolean, verbose?: boolea
 };
 /** Get the version of npmglobalize itself */
 export declare function getToolVersion(): string;
-export declare function globalize(cwd: string, options?: GlobalizeOptions): Promise<boolean>;
+export declare function globalize(cwd: string, options?: GlobalizeOptions, configOptions?: Partial<GlobalizeOptions>): Promise<boolean>;
 declare const _default: {
     globalize: typeof globalize;
     transformDeps: typeof transformDeps;

package/lib.js

@@ -8,12 +8,14 @@ import readline from 'readline';
 import libversion from 'libnpmversion';
 import JSON5 from 'json5';
 import { fileURLToPath } from 'url';
-/** ANSI color codes */
+import { styleText } from 'util';
+/** Color/style helpers using Node.js styleText (Node 24+) */
 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`,
+    red: (text) => styleText('red', text),
+    yellow: (text) => styleText('yellow', text),
+    green: (text) => styleText('green', text),
+    italic: (text) => styleText('italic', text),
+    dim: (text) => styleText('dim', text),
 };
 const DEP_KEYS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
 /** Read and parse package.json from a directory */
@@ -100,7 +102,7 @@ export function writeConfig(dir, config, explicitKeys) {
             else if (key === 'gitVisibility')
                 comment = '  // private (default) or public';
             else if (key === 'npmVisibility')
-                comment = '  // private or public (default)';
+                comment = '  // private (default) or public';
             else if (key === 'bump')
                 comment = '  // patch (default), minor, or major';
             else if (key === 'fix')
@@ -183,6 +185,33 @@ export function checkPackageExists(packageName) {
         return false;
     }
 }
+/** Check npm package access level (public/restricted/null if not published) */
+export function checkNpmAccess(packageName) {
+    try {
+        const result = spawnSync('npm', ['view', packageName, '--json'], {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            shell: true
+        });
+        if (result.status === 0 && result.stdout) {
+            const data = JSON.parse(result.stdout);
+            // npm view returns the latest version's info
+            // Scoped packages are 'restricted' by default, unscoped are 'public'
+            // The access field isn't always present, so we infer from scope
+            if (packageName.startsWith('@')) {
+                // Scoped package - check if it exists
+                return 'restricted'; // Scoped packages default to restricted
+            }
+            else {
+                return 'public'; // Unscoped packages are always public
+            }
+        }
+        return null; // Package doesn't exist on npm
+    }
+    catch (error) {
+        return null;
+    }
+}
 /** Parse semver version string to major.minor.patch */
 function parseSemver(version) {
     const clean = version.replace(/^[^\d]*/, ''); // Remove ^, ~, etc.
@@ -1163,12 +1192,63 @@ export function getToolVersion() {
         return 'unknown';
     }
 }
-export async function globalize(cwd, options = {}) {
-    const { bump = 'patch', noPublish = 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, updateDeps = false, updateMajor = false, publishDeps = true, // Default to publishing deps for safety
+export async function globalize(cwd, options = {}, configOptions = {}) {
+    const { bump = 'patch', noPublish = false, cleanup = false, install = false, wsl = false, force = false, files = true, dryRun = false, quiet = true, verbose = false, init = false, gitVisibility = 'private', npmVisibility = 'private', message, conform = false, asis = false, updateDeps = false, updateMajor = false, publishDeps = true, // Default to publishing deps for safety
     forcePublish = false, fix = false, fixTags = false, rebase = false, show = false } = options;
     // Show tool version
     const toolVersion = getToolVersion();
     console.log(colors.italic(`npmglobalize v${toolVersion}`));
+    // Show settings from .globalize.json5 if any
+    if (Object.keys(configOptions).length > 0) {
+        const settings = [];
+        if (configOptions.install)
+            settings.push('--install');
+        if (configOptions.npmVisibility)
+            settings.push(`--npm-visibility ${configOptions.npmVisibility}`);
+        if (configOptions.gitVisibility)
+            settings.push(`--git-visibility ${configOptions.gitVisibility}`);
+        if (configOptions.conform)
+            settings.push('--conform');
+        if (configOptions.asis)
+            settings.push('--asis');
+        if (configOptions.updateDeps)
+            settings.push('--update-deps');
+        if (configOptions.updateMajor)
+            settings.push('--update-major');
+        if (configOptions.fix)
+            settings.push('--fix');
+        if (configOptions.fixTags)
+            settings.push('--fix-tags');
+        if (configOptions.rebase)
+            settings.push('--rebase');
+        if (configOptions.force)
+            settings.push('--force');
+        if (configOptions.verbose)
+            settings.push('--verbose');
+        if (configOptions.dryRun)
+            settings.push('--dry-run');
+        if (configOptions.bump)
+            settings.push(`--bump ${configOptions.bump}`);
+        if (configOptions.noPublish)
+            settings.push('--no-publish');
+        if (configOptions.cleanup)
+            settings.push('--cleanup');
+        if (configOptions.wsl)
+            settings.push('--wsl');
+        if (configOptions.files === false)
+            settings.push('--no-files');
+        if (configOptions.quiet === false)
+            settings.push('--no-quiet');
+        if (configOptions.publishDeps === false)
+            settings.push('--no-publish-deps');
+        if (configOptions.forcePublish)
+            settings.push('--force-publish');
+        if (configOptions.show)
+            settings.push('--show');
+        if (settings.length > 0) {
+            console.log(colors.dim(`Settings from .globalize.json5: ${settings.join(', ')}`));
+        }
+    }
     console.log('');
     // Check ignore files first (unless cleanup mode)
     if (!cleanup && !asis) {
@@ -1431,28 +1511,66 @@ export async function globalize(cwd, options = {}) {
         }
         console.log(colors.yellow('Continuing with --force despite errors...'));
     }
-    // Check npm visibility - explicit confirmation
+    // Check npm visibility and current publication status
+    const currentAccess = checkNpmAccess(pkg.name);
+    const isScoped = pkg.name.startsWith('@');
     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;
+        // User explicitly wants private publication
+        if (!isScoped) {
+            console.error(colors.red(`ERROR: Private packages must be scoped (e.g., @bobfrankston/${pkg.name})`));
+            return false;
+        }
+        if (currentAccess === 'public') {
+            console.error(colors.red(`ERROR: Package '${pkg.name}' is currently PUBLIC on npm.`));
+            console.error(colors.red(`Cannot change to private. Options:`));
+            console.error(colors.yellow(`  1. Deprecate the public package: npm deprecate ${pkg.name} "moved to private"`));
+            console.error(colors.yellow(`  2. Continue as public: npmglobalize --npm public`));
+            console.error(colors.yellow(`  3. Use a different package name`));
+            return false;
+        }
+        // Don't set "private": true in package.json - that blocks all publishing
+        console.log(`Package '${pkg.name}' will publish as PRIVATE (restricted access).`);
+        if (!currentAccess) {
+            console.log(colors.dim(`  First publish - requires paid npm account`));
         }
     }
     else if (npmVisibility === 'public') {
-        // Explicit public - inform user
+        // User explicitly wants public
+        if (currentAccess === 'restricted') {
+            console.error(colors.red(`ERROR: Package '${pkg.name}' is currently PRIVATE on npm.`));
+            console.error(colors.red(`Cannot change to public. Options:`));
+            console.error(colors.yellow(`  1. Unpublish and republish: npm unpublish ${pkg.name} --force`));
+            console.error(colors.yellow(`  2. Continue as private: npmglobalize --npm private`));
+            console.error(colors.yellow(`  3. Use a different package name`));
+            return false;
+        }
         console.log(`Will publish '${pkg.name}' to PUBLIC npm registry.`);
+        console.log(colors.yellow(`  To use, run: npm install ${pkg.name}`));
     }
     else {
-        // No explicit setting - check current state
-        if (pkg.private) {
-            console.log(`Package is marked PRIVATE - will not publish to npm.`);
+        // No explicit setting - preserve current state or use defaults
+        if (currentAccess === 'public') {
+            console.log(`Package '${pkg.name}' is PUBLIC on npm (will maintain status).`);
+        }
+        else if (currentAccess === 'restricted') {
+            console.log(`Package '${pkg.name}' is PRIVATE on npm (will maintain status).`);
+        }
+        else if (pkg.private) {
+            console.log(`Package '${pkg.name}' marked PRIVATE (package.json "private": true)`);
+            console.log(colors.dim(`  npm will reject publication - use for internal/local packages only`));
         }
         else {
-            console.log(`Will publish '${pkg.name}' to PUBLIC npm registry.`);
+            // New package - default to private
+            if (isScoped) {
+                console.log(`Package '${pkg.name}' will publish as PRIVATE (default for new packages).`);
+                console.log(colors.dim(`  Use --npm public to make it public`));
+            }
+            else {
+                console.log(colors.yellow(`WARNING: Package '${pkg.name}' is unscoped and will be PUBLIC.`));
+                console.log(colors.yellow(`  Unscoped packages cannot be private on npm.`));
+                console.log(colors.yellow(`  Consider using a scoped name: @bobfrankston/${pkg.name}`));
+                console.log(colors.yellow(`  Or use --npm public to confirm public publishing`));
+            }
         }
     }
     // Update existing npm dependencies if requested
@@ -1895,9 +2013,23 @@ export async function globalize(cwd, options = {}) {
         }
         // Publish the tarball
         const npmArgs = ['publish', tarballName];
+        // Determine access level
         if (npmVisibility === 'public') {
+            // Explicitly public
             npmArgs.push('--access', 'public');
         }
+        else if (npmVisibility === 'private') {
+            // Explicitly private - don't add flag, scoped packages are restricted by default
+            // npmArgs.push('--access', 'restricted'); // Not needed, it's the default for scoped
+        }
+        else {
+            // No explicit setting - check current npm state
+            if (currentAccess === 'public') {
+                // Maintain public status
+                npmArgs.push('--access', 'public');
+            }
+            // If restricted or new, use defaults (scoped=restricted, unscoped=public)
+        }
         if (quiet) {
             npmArgs.push('--quiet');
         }
@@ -2027,7 +2159,10 @@ export async function globalize(cwd, options = {}) {
             }
             return false;
         }
-        console.log(colors.green('✓ Published to npm'));
+        // Determine what was published
+        const finalAccess = currentAccess || (isScoped ? 'restricted' : 'public');
+        const accessLabel = finalAccess === 'restricted' ? 'PRIVATE' : 'PUBLIC';
+        console.log(colors.green(`✓ Published to npm as ${accessLabel}`));
     }
     else {
         console.log(`  [dry-run] Would run: npm publish ${quiet ? '--quiet' : ''}`);

package/package.json

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