@bobfrankston/npmglobalize 1.0.78 → 1.0.80

package/cli.js

@@ -2,7 +2,7 @@
 /**
  * npmglobalize CLI - Transform file: dependencies to npm versions for publishing
  */
-import { globalize, readConfig } from './lib.js';
+import { globalize, globalizeWorkspace, readConfig, readPackageJson, writeConfig, writePackageJson } from './lib.js';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
@@ -65,7 +65,8 @@ Dependency Options:
   --fix                     Run npm audit fix after transformation
 
 Install Options:
-  --install, -i    Global install after publish (Windows)
+  --install, -i    Global install after publish (from registry)
+  --link           Global install via symlink (npm install -g .)
   --wsl            Also install globally in WSL
 
 Mode Options:
@@ -78,6 +79,11 @@ Git/npm Visibility:
   --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
+
 Other Options:
   --init          Initialize git/npm if needed
   --force         Continue despite git errors
@@ -88,6 +94,7 @@ Other Options:
   --asis          Skip ignore file checks (or set "asis": true in .globalize.json5)
   --rebase        Automatically rebase if local is behind remote
   --show          Show package.json dependency changes
+  --package, -pkg  Update package.json scripts to use npmglobalize
   -h, --help      Show this help
   -v, --version   Show version number
 
@@ -102,18 +109,27 @@ Examples:
   npmglobalize -npd                  Skip auto-publishing file: deps (use with caution)
   npmglobalize --force-publish       Force republish all file: dependencies
   npmglobalize --fix                 Fix security vulnerabilities
-  npmglobalize --install --wsl       Release + install on Windows and WSL
+  npmglobalize --install --wsl       Release + install on Windows and WSL (from registry)
+  npmglobalize --link --wsl          Release + link on Windows and WSL (symlink)
   npmglobalize -np                   Just transform, no publish
   npmglobalize --cleanup             Restore original dependencies
   npmglobalize --init                Initialize new git repo + release
   npmglobalize --dry-run             Preview what would happen
+  npmglobalize --package             Migrate scripts to use npmglobalize
+
+Workspace (auto-detected when run from a workspace root):
+  npmglobalize                       Publish all workspace packages in dependency order
+  npmglobalize -w msgcommon          Publish only msgcommon
+  npmglobalize --no-workspace        Skip workspace detection, run single-package mode
+  npmglobalize --continue-on-error   Keep going if a package fails
 `);
 }
 function parseArgs(args) {
     const options = {
         help: false,
         version: false,
-        error: ''
+        error: '',
+        explicitKeys: new Set()
     };
     const unrecognized = [];
     const positional = [];
@@ -148,25 +164,35 @@ function parseArgs(args) {
             case '--install':
             case '-i':
                 options.install = true;
+                options.explicitKeys.add('install');
                 break;
             case '--noinstall':
             case '-ni':
                 options.install = false;
+                options.explicitKeys.add('install');
+                break;
+            case '--link':
+                options.link = true;
+                options.explicitKeys.add('link');
                 break;
             case '--wsl':
                 options.wsl = true;
+                options.explicitKeys.add('wsl');
                 break;
             case '--nowsl':
                 options.wsl = false;
+                options.explicitKeys.add('wsl');
                 break;
             case '--force':
                 options.force = true;
                 break;
             case '--files':
                 options.files = true;
+                options.explicitKeys.add('files');
                 break;
             case '--nofiles':
                 options.files = false;
+                options.explicitKeys.add('files');
                 break;
             case '--dry-run':
                 options.dryRun = true;
@@ -185,6 +211,7 @@ function parseArgs(args) {
                 i++;
                 if (args[i] === 'private' || args[i] === 'public') {
                     options.gitVisibility = args[i];
+                    options.explicitKeys.add('gitVisibility');
                 }
                 else {
                     options.error = `--git requires 'private' or 'public', got: ${args[i]}`;
@@ -194,6 +221,7 @@ function parseArgs(args) {
                 i++;
                 if (args[i] === 'private' || args[i] === 'public') {
                     options.npmVisibility = args[i];
+                    options.explicitKeys.add('npmVisibility');
                 }
                 else {
                     options.error = `--npm requires 'private' or 'public', got: ${args[i]}`;
@@ -244,9 +272,33 @@ function parseArgs(args) {
                 break;
             case '--fix':
                 options.fix = true;
+                options.explicitKeys.add('fix');
                 break;
             case '--no-fix':
                 options.fix = false;
+                options.explicitKeys.add('fix');
+                break;
+            case '--workspace':
+            case '-w':
+                i++;
+                if (args[i]) {
+                    if (!options.workspaceFilter)
+                        options.workspaceFilter = [];
+                    options.workspaceFilter.push(args[i]);
+                }
+                else {
+                    options.error = '-w/--workspace requires a package name';
+                }
+                break;
+            case '--no-workspace':
+                options.noWorkspace = true;
+                break;
+            case '--continue-on-error':
+                options.continueOnError = true;
+                break;
+            case '--package':
+            case '-pkg':
+                options.package = true;
                 break;
             default:
                 if (arg.startsWith('-')) {
@@ -341,10 +393,51 @@ export async function main() {
             process.exit(1);
         }
     }
+    // Handle --package: update scripts in target package.json
+    if (cliOptions.package) {
+        const pkg = readPackageJson(cwd);
+        if (!pkg.scripts)
+            pkg.scripts = {};
+        const scripts = pkg.scripts;
+        const changes = [];
+        if (scripts.release) {
+            scripts['old-release'] = scripts.release;
+            changes.push(`renamed release → old-release`);
+        }
+        if (scripts.installer) {
+            scripts['old-installer'] = scripts.installer;
+            changes.push(`renamed installer → old-installer`);
+        }
+        scripts.release = 'npmglobalize';
+        changes.push(`added release: "npmglobalize"`);
+        writePackageJson(cwd, pkg);
+        console.log(`Updated ${path.join(cwd, 'package.json')} scripts:`);
+        changes.forEach(c => console.log(`  ${c}`));
+        process.exit(0);
+    }
     // Load config file and merge with CLI options (CLI takes precedence)
     const configOptions = readConfig(cwd);
     const options = { ...configOptions, ...cliOptions };
+    // Persist explicitly set CLI flags to .globalize.json5
+    if (cliOptions.explicitKeys.size > 0) {
+        const persistable = { ...configOptions };
+        for (const key of cliOptions.explicitKeys) {
+            persistable[key] = options[key];
+        }
+        writeConfig(cwd, persistable, cliOptions.explicitKeys);
+    }
     try {
+        // Auto-detect workspace root: private package with workspaces[] field
+        if (!options.noWorkspace) {
+            const pkgJsonPath = path.join(cwd, 'package.json');
+            if (fs.existsSync(pkgJsonPath)) {
+                const rootPkg = readPackageJson(cwd);
+                if (rootPkg.private && Array.isArray(rootPkg.workspaces)) {
+                    const result = await globalizeWorkspace(cwd, options, configOptions);
+                    process.exit(result.success ? 0 : 1);
+                }
+            }
+        }
         const success = await globalize(cwd, options, configOptions);
         process.exit(success ? 0 : 1);
     }

package/index.d.ts

@@ -3,4 +3,5 @@
  * npmglobalize - Main entry point
  */
 import './cli.js';
+export { globalize, globalizeWorkspace, GlobalizeOptions, WorkspaceResult } from './lib.js';
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -4,6 +4,7 @@
  */
 import './cli.js';
 import { main } from './cli.js';
+export { globalize, globalizeWorkspace } from './lib.js';
 if (import.meta.main) {
     main();
 }

package/lib.d.ts

@@ -17,8 +17,10 @@ export interface GlobalizeOptions {
     noPublish?: boolean;
     /** Restore from .dependencies */
     cleanup?: boolean;
-    /** Global install after publish */
+    /** Global install after publish (from registry) */
     install?: boolean;
+    /** Global install via symlink (npm install -g .) */
+    link?: boolean;
     /** Also install in WSL */
     wsl?: boolean;
     /** Continue despite git errors */
@@ -59,6 +61,30 @@ export interface GlobalizeOptions {
     rebase?: boolean;
     /** Show package.json dependency changes */
     show?: boolean;
+    /** Filter to specific workspace packages (by name or dir name) */
+    workspaceFilter?: string[];
+    /** Disable workspace mode even at a workspace root */
+    noWorkspace?: boolean;
+    /** Continue processing remaining packages if one fails (workspace mode) */
+    continueOnError?: boolean;
+    /** Update package.json scripts to use npmglobalize */
+    package?: boolean;
+    /** Internal: signals this call is from workspace orchestrator */
+    _fromWorkspace?: boolean;
+}
+/** Result from a single package in workspace mode */
+interface WorkspacePackageResult {
+    name: string;
+    dir: string;
+    success: boolean;
+    version?: string;
+    error?: string;
+}
+/** Aggregate result from workspace orchestration */
+export interface WorkspaceResult {
+    success: boolean;
+    packages: WorkspacePackageResult[];
+    publishOrder: string[];
 }
 /** Read and parse package.json from a directory */
 export declare function readPackageJson(dir: string): any;
@@ -101,6 +127,20 @@ export declare function getFileRefs(pkg: any): Map<string, {
     name: string;
     value: string;
 }>;
+/** Resolve workspace entries to package info. Skips dirs without package.json or with private:true. */
+export declare function resolveWorkspacePackages(rootDir: string): Array<{
+    name: string;
+    dir: string;
+    pkg: any;
+}>;
+/** Build a dependency graph among workspace packages. Returns Map<name, Set<depName>>. */
+export declare function buildDependencyGraph(packages: Array<{
+    name: string;
+    dir: string;
+    pkg: any;
+}>): Map<string, Set<string>>;
+/** Topological sort with cycle detection. Returns package names in dependency order. */
+export declare function topologicalSort(graph: Map<string, Set<string>>): string[];
 /** Transform file: dependencies to npm versions */
 export declare function transformDeps(pkg: any, baseDir: string, verbose?: boolean, forcePublish?: boolean): {
     transformed: boolean;
@@ -173,8 +213,11 @@ 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, configOptions?: Partial<GlobalizeOptions>): Promise<boolean>;
+/** Orchestrate globalize across all packages in an npm workspace */
+export declare function globalizeWorkspace(rootDir: string, options?: GlobalizeOptions, configOptions?: Partial<GlobalizeOptions>): Promise<WorkspaceResult>;
 declare const _default: {
     globalize: typeof globalize;
+    globalizeWorkspace: typeof globalizeWorkspace;
     transformDeps: typeof transformDeps;
     restoreDeps: typeof restoreDeps;
     readPackageJson: typeof readPackageJson;

package/lib.js

@@ -138,7 +138,9 @@ export function writeConfig(dir, config, explicitKeys) {
             // Add inline comment for clarity
             let comment = '';
             if (key === 'install')
-                comment = '  // Auto-install globally after publish';
+                comment = '  // Auto-install globally after publish (from registry)';
+            else if (key === 'link')
+                comment = '  // Install globally via symlink (npm install -g .)';
             else if (key === 'wsl')
                 comment = '  // Also install in WSL';
             else if (key === 'files')
@@ -164,7 +166,8 @@ export function writeConfig(dir, config, explicitKeys) {
     // 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('  // "install": false             // Auto-install globally after publish (from registry)');
+    lines.push('  // "link": false               // Install globally via symlink (npm install -g .)');
     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');
@@ -415,6 +418,91 @@ export function getFileRefs(pkg) {
     }
     return refs;
 }
+// ─── Workspace helpers ───────────────────────────────────────────────
+/** Resolve workspace entries to package info. Skips dirs without package.json or with private:true. */
+export function resolveWorkspacePackages(rootDir) {
+    const rootPkg = readPackageJson(rootDir);
+    const workspaces = rootPkg.workspaces;
+    if (!Array.isArray(workspaces))
+        return [];
+    const results = [];
+    for (const entry of workspaces) {
+        const pkgDir = path.resolve(rootDir, entry);
+        const pkgJsonPath = path.join(pkgDir, 'package.json');
+        if (!fs.existsSync(pkgJsonPath))
+            continue;
+        const pkg = readPackageJson(pkgDir);
+        if (pkg.private)
+            continue; // skip private packages (they can't be published)
+        results.push({ name: pkg.name || entry, dir: pkgDir, pkg });
+    }
+    return results;
+}
+/** Build a dependency graph among workspace packages. Returns Map<name, Set<depName>>. */
+export function buildDependencyGraph(packages) {
+    const nameSet = new Set(packages.map(p => p.name));
+    const dirToName = new Map();
+    for (const p of packages) {
+        dirToName.set(p.dir, p.name);
+    }
+    const graph = new Map();
+    for (const p of packages) {
+        const deps = new Set();
+        for (const depKey of DEP_KEYS) {
+            if (!p.pkg[depKey])
+                continue;
+            for (const [depName, depValue] of Object.entries(p.pkg[depKey])) {
+                // Check by npm name
+                if (nameSet.has(depName)) {
+                    deps.add(depName);
+                    continue;
+                }
+                // Check file: refs that resolve to a sibling workspace dir
+                if (isFileRef(depValue)) {
+                    const resolved = resolveFilePath(depValue, p.dir);
+                    const resolvedNorm = path.resolve(resolved);
+                    const match = dirToName.get(resolvedNorm);
+                    if (match) {
+                        deps.add(match);
+                    }
+                }
+            }
+        }
+        graph.set(p.name, deps);
+    }
+    return graph;
+}
+/** Topological sort with cycle detection. Returns package names in dependency order. */
+export function topologicalSort(graph) {
+    const visited = new Set();
+    const visiting = new Set(); // cycle detection
+    const result = [];
+    function visit(node) {
+        if (visited.has(node))
+            return;
+        if (visiting.has(node)) {
+            throw new Error(`Circular dependency detected involving: ${node}`);
+        }
+        visiting.add(node);
+        const deps = graph.get(node);
+        if (deps) {
+            for (const dep of deps) {
+                if (dep === node)
+                    continue; // skip self-references
+                if (graph.has(dep)) { // only visit workspace-internal deps
+                    visit(dep);
+                }
+            }
+        }
+        visiting.delete(node);
+        visited.add(node);
+        result.push(node);
+    }
+    for (const node of graph.keys()) {
+        visit(node);
+    }
+    return result;
+}
 /** Transform file: dependencies to npm versions */
 export function transformDeps(pkg, baseDir, verbose = false, forcePublish = false) {
     let transformed = false;
@@ -1308,16 +1396,20 @@ export function getToolVersion() {
     }
 }
 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
+    const { bump = 'patch', noPublish = false, cleanup = false, install = false, link = 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
+    // Show tool version (skip when called from workspace orchestrator)
     const toolVersion = getToolVersion();
-    console.log(colors.italic(`npmglobalize v${toolVersion}`));
+    if (!options._fromWorkspace) {
+        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.link)
+            settings.push('--link');
         if (configOptions.npmVisibility)
             settings.push(`--npm-visibility ${configOptions.npmVisibility}`);
         if (configOptions.gitVisibility)
@@ -1579,6 +1671,26 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     }
     // Read package.json
     const pkg = readPackageJson(cwd);
+    // Run build step if package.json has a build script
+    if (pkg.scripts?.build) {
+        console.log('Running build...');
+        if (!dryRun) {
+            const buildResult = runCommand('npm', ['run', 'build'], { cwd, silent: !verbose });
+            if (!buildResult.success) {
+                console.error(colors.red('ERROR: Build failed:'), buildResult.stderr || buildResult.output);
+                if (!force) {
+                    return false;
+                }
+                console.log(colors.yellow('Continuing with --force despite build failure...'));
+            }
+            else {
+                console.log(colors.green('✓ Build succeeded'));
+            }
+        }
+        else {
+            console.log('  [dry-run] Would run: npm run build');
+        }
+    }
     // Pre-flight check: fix version/tag mismatches silently
     if (!dryRun) {
         fixVersionTagMismatch(cwd, pkg, verbose);
@@ -1916,40 +2028,51 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     if (!currentGitStatus.hasUncommitted && !message && !justInitialized && !isFirstPublish) {
         console.log('');
         console.log('No changes to commit and no custom message specified.');
-        // If install flag is set, install from local directory
-        if (install || wsl) {
+        // If install/link flag is set, install globally
+        if (install || link || wsl) {
             if (verbose) {
                 console.log('');
-                console.log('Installing from local directory...');
+                console.log(link ? 'Installing from local directory (link)...' : 'Installing from registry...');
             }
             const pkgName = pkg.name;
-            if (!pkg.bin && (install || wsl)) {
+            const pkgVersion = pkg.version;
+            if (!pkg.bin && (install || link || wsl)) {
                 console.log(colors.yellow('Note: This is a library (no bin field), skipping global installation.'));
                 console.log(colors.yellow('To use in projects: npm install ' + pkgName));
             }
             else {
-                if (install) {
-                    console.log(`Installing ${pkgName} globally from local directory...`);
+                if (link) {
+                    console.log(`Installing ${pkgName} globally from local directory (link)...`);
                     const localInstallResult = runCommand('npm', ['install', '-g', '.'], { cwd, silent: false });
                     if (localInstallResult.success) {
-                        const version = pkg.version;
-                        console.log(colors.green(`✓ Installed globally: ${pkgName}@${version}`));
+                        console.log(colors.green(`✓ Linked globally: ${pkgName}@${pkgVersion}`));
                     }
                     else {
-                        console.error(colors.red(`✗ Global install failed`));
+                        console.error(colors.red(`✗ Global link install failed`));
                         console.error(colors.yellow('  Try running manually: npm install -g .'));
                     }
                 }
+                else if (install) {
+                    console.log(`Installing ${pkgName}@${pkgVersion} globally from registry...`);
+                    const registryInstallResult = runCommand('npm', ['install', '-g', `${pkgName}@${pkgVersion}`], { cwd, silent: false });
+                    if (registryInstallResult.success) {
+                        console.log(colors.green(`✓ Installed globally: ${pkgName}@${pkgVersion}`));
+                    }
+                    else {
+                        console.error(colors.red(`✗ Global install failed`));
+                        console.error(colors.yellow(`  Try running manually: npm install -g ${pkgName}@${pkgVersion}`));
+                    }
+                }
                 if (wsl) {
-                    console.log(`Installing ${pkgName} in WSL from local directory...`);
-                    const wslInstallResult = runCommand('wsl', ['npm', 'install', '-g', '.'], { cwd, silent: false });
+                    const wslArgs = link ? ['npm', 'install', '-g', '.'] : ['npm', 'install', '-g', `${pkgName}@${pkgVersion}`];
+                    console.log(`Installing ${pkgName} in WSL${link ? ' (link)' : ' from registry'}...`);
+                    const wslInstallResult = runCommand('wsl', wslArgs, { cwd, silent: false });
                     if (wslInstallResult.success) {
-                        const version = pkg.version;
-                        console.log(colors.green(`✓ Installed in WSL: ${pkgName}@${version}`));
+                        console.log(colors.green(`✓ Installed in WSL: ${pkgName}@${pkgVersion}`));
                     }
                     else {
                         console.error(colors.red(`✗ WSL install failed`));
-                        console.error(colors.yellow('  Try running manually in WSL: npm install -g .'));
+                        console.error(colors.yellow('  Try running manually in WSL: npm install -g ' + (link ? '.' : pkgName)));
                     }
                 }
             }
@@ -2363,21 +2486,20 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     const updatedPkg = readPackageJson(cwd); // Re-read to get updated version
     const pkgName = updatedPkg.name;
     const pkgVersion = updatedPkg.version;
-    if (!updatedPkg.bin && (install || wsl)) {
+    if (!updatedPkg.bin && (install || link || wsl)) {
         console.log(colors.yellow('Note: This is a library (no bin field), skipping global installation.'));
         console.log(colors.yellow('To use in projects: npm install ' + pkgName));
     }
     else {
-        if (install) {
-            console.log(`Installing globally: ${pkgName}@${pkgVersion}...`);
+        if (link) {
+            console.log(`Linking globally: ${pkgName}@${pkgVersion}...`);
             if (!dryRun) {
-                // Install from local directory (faster and works immediately after publish)
                 const installResult = runCommand('npm', ['install', '-g', '.'], { cwd, silent: false });
                 if (installResult.success) {
-                    console.log(colors.green(`✓ Installed globally: ${pkgName}@${pkgVersion}`));
+                    console.log(colors.green(`✓ Linked globally: ${pkgName}@${pkgVersion}`));
                 }
                 else {
-                    console.error(colors.red(`✗ Global install failed`));
+                    console.error(colors.red(`✗ Global link install failed`));
                     console.error(colors.yellow('  Try running manually: npm install -g .'));
                 }
             }
@@ -2385,11 +2507,27 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                 console.log(`  [dry-run] Would run: npm install -g .`);
             }
         }
+        else if (install) {
+            console.log(`Installing globally from registry: ${pkgName}@${pkgVersion}...`);
+            if (!dryRun) {
+                const installResult = runCommand('npm', ['install', '-g', `${pkgName}@${pkgVersion}`], { cwd, silent: false });
+                if (installResult.success) {
+                    console.log(colors.green(`✓ Installed globally: ${pkgName}@${pkgVersion}`));
+                }
+                else {
+                    console.error(colors.red(`✗ Global install failed`));
+                    console.error(colors.yellow(`  Try running manually: npm install -g ${pkgName}@${pkgVersion}`));
+                }
+            }
+            else {
+                console.log(`  [dry-run] Would run: npm install -g ${pkgName}@${pkgVersion}`);
+            }
+        }
         if (wsl) {
-            console.log(`Installing in WSL: ${pkgName}@${pkgVersion}...`);
+            const wslArgs = link ? ['npm', 'install', '-g', '.'] : ['npm', 'install', '-g', `${pkgName}@${pkgVersion}`];
+            console.log(`Installing in WSL${link ? ' (link)' : ' from registry'}: ${pkgName}@${pkgVersion}...`);
             if (!dryRun) {
-                // Install from local directory in WSL
-                const wslResult = runCommand('wsl', ['npm', 'install', '-g', '.'], { cwd, silent: false });
+                const wslResult = runCommand('wsl', wslArgs, { cwd, silent: false });
                 if (wslResult.success) {
                     console.log(colors.green(`✓ Installed in WSL: ${pkgName}@${pkgVersion}`));
                 }
@@ -2398,7 +2536,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                 }
             }
             else {
-                console.log(`  [dry-run] Would run: wsl npm install -g ${pkgName}`);
+                console.log(`  [dry-run] Would run: wsl npm install -g ${link ? '.' : pkgName}`);
             }
         }
     }
@@ -2438,7 +2576,10 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     console.log(`  Version: ${colors.green('v' + finalPkg.version)}`);
     console.log(`  Published: ${colors.green('✓')} (${accessLabel})`);
     console.log(`  Git pushed: ${colors.green('✓')}`);
-    if (install) {
+    if (link) {
+        console.log(`  Linked globally: ${colors.green('✓')}`);
+    }
+    else if (install) {
         console.log(`  Installed globally: ${colors.green('✓')}`);
     }
     if (wsl) {
@@ -2457,8 +2598,128 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     }
     return true;
 }
+// ─── Workspace orchestration ─────────────────────────────────────────
+/** Orchestrate globalize across all packages in an npm workspace */
+export async function globalizeWorkspace(rootDir, options = {}, configOptions = {}) {
+    const toolVersion = getToolVersion();
+    console.log(colors.italic(`npmglobalize v${toolVersion}`) + colors.dim(' (workspace mode)'));
+    console.log('');
+    // Resolve workspace packages
+    const packages = resolveWorkspacePackages(rootDir);
+    if (packages.length === 0) {
+        console.error(colors.red('No publishable workspace packages found.'));
+        return { success: false, packages: [], publishOrder: [] };
+    }
+    // Build dependency graph and determine publish order
+    const graph = buildDependencyGraph(packages);
+    const publishOrder = topologicalSort(graph);
+    console.log(`Workspace: ${colors.green(path.basename(rootDir))}`);
+    console.log(`Packages (${packages.length}): ${packages.map(p => p.name).join(', ')}`);
+    console.log(`Publish order: ${publishOrder.join(' → ')}`);
+    console.log('');
+    // Handle --cleanup: restore deps for all packages and return
+    if (options.cleanup) {
+        console.log('Restoring workspace dependencies...');
+        for (const pkgName of publishOrder) {
+            const pkgInfo = packages.find(p => p.name === pkgName);
+            if (!pkgInfo)
+                continue;
+            const pkg = readPackageJson(pkgInfo.dir);
+            const restored = restoreDeps(pkg);
+            if (restored) {
+                writePackageJson(pkgInfo.dir, pkg);
+                console.log(`  ${colors.green('✓')} ${pkgName}: restored`);
+            }
+            else {
+                console.log(`  ${colors.dim('–')} ${pkgName}: nothing to restore`);
+            }
+        }
+        return { success: true, packages: [], publishOrder };
+    }
+    // Apply workspace filter if specified
+    let filteredOrder = publishOrder;
+    if (options.workspaceFilter && options.workspaceFilter.length > 0) {
+        const filter = new Set(options.workspaceFilter);
+        filteredOrder = publishOrder.filter(name => {
+            const pkgInfo = packages.find(p => p.name === name);
+            if (!pkgInfo)
+                return false;
+            // Match by package name or directory basename
+            return filter.has(name) || filter.has(path.basename(pkgInfo.dir));
+        });
+        if (filteredOrder.length === 0) {
+            console.error(colors.red(`No packages matched filter: ${options.workspaceFilter.join(', ')}`));
+            return { success: false, packages: [], publishOrder };
+        }
+        console.log(`Filtered to: ${filteredOrder.join(', ')}`);
+        console.log('');
+    }
+    // Process each package in dependency order
+    const results = [];
+    for (const pkgName of filteredOrder) {
+        const pkgInfo = packages.find(p => p.name === pkgName);
+        if (!pkgInfo)
+            continue;
+        console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log(`  Package: ${colors.green(pkgName)}`);
+        console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        // Merge configs: root config < package config < CLI options
+        const pkgConfig = readConfig(pkgInfo.dir);
+        const mergedConfig = { ...configOptions, ...pkgConfig };
+        const mergedOptions = {
+            ...mergedConfig,
+            ...options,
+            publishDeps: false, // workspace handles ordering; avoid double-publish
+            _fromWorkspace: true,
+        };
+        try {
+            const success = await globalize(pkgInfo.dir, mergedOptions, mergedConfig);
+            const updatedPkg = readPackageJson(pkgInfo.dir);
+            results.push({
+                name: pkgName,
+                dir: pkgInfo.dir,
+                success,
+                version: updatedPkg.version,
+            });
+            if (!success && !options.continueOnError) {
+                console.error(colors.red(`\nStopping: ${pkgName} failed. Use --continue-on-error to keep going.`));
+                break;
+            }
+        }
+        catch (error) {
+            results.push({
+                name: pkgName,
+                dir: pkgInfo.dir,
+                success: false,
+                error: error.message,
+            });
+            console.error(colors.red(`\nError processing ${pkgName}: ${error.message}`));
+            if (!options.continueOnError) {
+                console.error(colors.red('Use --continue-on-error to continue with remaining packages.'));
+                break;
+            }
+        }
+        console.log('');
+    }
+    // Print workspace summary
+    const allSuccess = results.every(r => r.success);
+    console.log('');
+    console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log(allSuccess ? colors.green('✓ Workspace Summary') : colors.red('✗ Workspace Summary'));
+    console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    for (const r of results) {
+        const status = r.success ? colors.green('✓') : colors.red('✗');
+        const ver = r.version ? ` v${r.version}` : '';
+        const err = r.error ? colors.red(` (${r.error})`) : '';
+        console.log(`  ${status} ${r.name}${ver}${err}`);
+    }
+    console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log('');
+    return { success: allSuccess, packages: results, publishOrder };
+}
 export default {
     globalize,
+    globalizeWorkspace,
     transformDeps,
     restoreDeps,
     readPackageJson,

package/package.json

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