@bobfrankston/npmglobalize 1.0.200 → 1.0.201

package/cli.js

@@ -112,6 +112,7 @@ Other Options:
   -force          Continue despite git errors
   -dry-run        Preview what would happen
   -quiet          Suppress npm warnings (default)
+  -noquiet        Show npm warnings (without -verbose's extra detail)
   -verbose        Show detailed output
   -conform        Update .gitignore/.npmignore to best practices
                   (noEmit projects: removes TS ignores from .npmignore)
@@ -268,6 +269,10 @@ function parseArgs(args) {
             case '-quiet':
                 options.quiet = true;
                 break;
+            case '-noquiet':
+                options.quiet = false;
+                options.explicitKeys.add('quiet');
+                break;
             case '-verbose':
                 options.verbose = true;
                 options.quiet = false;

package/lib.js

@@ -5334,9 +5334,9 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         if (configOptions.link)
             settings.push('--link');
         if (configOptions.npmVisibility)
-            settings.push(`--npm-visibility ${configOptions.npmVisibility}`);
+            settings.push(`-npm ${configOptions.npmVisibility}`);
         if (configOptions.gitVisibility)
-            settings.push(`--git-visibility ${configOptions.gitVisibility}`);
+            settings.push(`-git ${configOptions.gitVisibility}`);
         if (configOptions.conform)
             settings.push('--conform');
         if (configOptions.asis)
@@ -5358,15 +5358,15 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         if (configOptions.dryRun)
             settings.push('--dry-run');
         if (configOptions.bump)
-            settings.push(`--bump ${configOptions.bump}`);
+            settings.push(`-${configOptions.bump}`);
         if (configOptions.cleanup)
             settings.push('--cleanup');
         if (configOptions.wsl)
             settings.push('--wsl');
         if (configOptions.files === false)
-            settings.push('--no-files');
+            settings.push('-nofiles');
         if (configOptions.quiet === false)
-            settings.push('--no-quiet');
+            settings.push('-noquiet');
         if (configOptions.publishDeps === false)
             settings.push('--no-publish-deps');
         if (configOptions.forcePublish)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.200",
+  "version": "1.0.201",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@bobfrankston/freezepak": "^0.1.9",
-    "@bobfrankston/importgen": "^0.1.39",
+    "@bobfrankston/importgen": "^0.1.40",
     "@bobfrankston/themecolors": "^0.1.8",
     "@bobfrankston/userconfig": "^1.0.10",
     "@npmcli/package-json": "^7.0.4",
@@ -60,7 +60,7 @@
   ".transformedSnapshot": {
     "dependencies": {
       "@bobfrankston/freezepak": "^0.1.9",
-      "@bobfrankston/importgen": "^0.1.39",
+      "@bobfrankston/importgen": "^0.1.40",
       "@bobfrankston/themecolors": "^0.1.8",
       "@bobfrankston/userconfig": "^1.0.10",
       "@npmcli/package-json": "^7.0.4",

package/lib/config.d.ts

@@ -1,23 +0,0 @@
-import { type NpmCommonConfig } from '@bobfrankston/userconfig';
-import { type GlobalizeOptions } from './types.js';
-/** Read and parse package.json from a directory */
-export declare function readPackageJson(dir: string): any;
-/** Global npm config from %USERPROFILE%\.userconfig\npm.json5 — via @bobfrankston/userconfig */
-export type UserNpmConfig = NpmCommonConfig;
-/** Get the .userconfig directory path (%USERPROFILE%\.userconfig) */
-export declare function getUserConfigDir(): string;
-/** Read global npm config from %USERPROFILE%\.userconfig\npm.json5 */
-export declare function readUserNpmConfig(): UserNpmConfig;
-/** Write global npm config to %USERPROFILE%\.userconfig\npm.json5 */
-export declare function writeUserNpmConfig(config: UserNpmConfig): void;
-/** Read .globalize.json5 config file */
-export declare function readConfig(dir: string): Partial<GlobalizeOptions>;
-/** Write .globalize.json5 config file */
-export declare function writeConfig(dir: string, config: Partial<GlobalizeOptions>, explicitKeys?: Set<string>): void;
-/** Write package.json to a directory */
-export declare function writePackageJson(dir: string, pkg: any): void;
-/** Resolve a file: path to absolute path */
-export declare function resolveFilePath(fileRef: string, baseDir: string): string;
-/** Check if a dependency value is a file: reference */
-export declare function isFileRef(value: string): boolean;
-//# sourceMappingURL=config.d.ts.map

package/lib/config.js

@@ -1,163 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import JSON5 from 'json5';
-import { readConfig as readUserConfig, writeConfig as writeUserConfig, configDir } from '@bobfrankston/userconfig';
-/** 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}`);
-    }
-    try {
-        return JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-    }
-    catch (error) {
-        throw new Error(`Failed to parse ${pkgPath}: ${error.message}`);
-    }
-}
-/** Get the .userconfig directory path (%USERPROFILE%\.userconfig) */
-export function getUserConfigDir() {
-    return configDir;
-}
-/** Read global npm config from %USERPROFILE%\.userconfig\npm.json5 */
-export function readUserNpmConfig() {
-    return readUserConfig();
-}
-/** Write global npm config to %USERPROFILE%\.userconfig\npm.json5 */
-export function writeUserNpmConfig(config) {
-    const existing = readUserConfig();
-    const merged = { ...existing, ...config };
-    writeUserConfig(merged);
-}
-/** Read .globalize.json5 config file */
-export function readConfig(dir) {
-    const configPath = path.join(dir, '.globalize.json5');
-    if (!fs.existsSync(configPath)) {
-        return {};
-    }
-    try {
-        const content = fs.readFileSync(configPath, 'utf-8');
-        return JSON5.parse(content);
-    }
-    catch (error) {
-        console.warn(`Warning: Could not parse .globalize.json5 config: ${error.message}`);
-        return {};
-    }
-}
-/** Write .globalize.json5 config file */
-export function writeConfig(dir, config, explicitKeys) {
-    const configPath = path.join(dir, '.globalize.json5');
-    // Define defaults to omit
-    const defaults = {
-        bump: 'patch',
-        files: true,
-        quiet: true,
-        gitVisibility: 'private',
-        npmVisibility: 'private',
-        install: false,
-        wsl: false,
-        force: false,
-        verbose: false,
-        freeze: false,
-        usePaths: true
-    };
-    // Read existing config to preserve values
-    const existing = readConfig(dir);
-    // Filter out temporary flags and default values (unless explicitly set)
-    const filtered = {};
-    const omitKeys = new Set(['cleanup', 'init', 'dryRun', 'message', 'conform', 'asis', 'help', 'error', 'updateDeps', 'updateMajor', 'publishDeps', 'publicDeps', 'forcePublish', 'once', 'cleanNestedModules']);
-    for (const [key, value] of Object.entries(config)) {
-        if (omitKeys.has(key))
-            continue;
-        // Keep if: already in config, explicitly set via CLI, or differs from default
-        const isExplicit = explicitKeys?.has(key);
-        const wasInConfig = key in existing;
-        const differsFromDefault = defaults[key] !== value;
-        if (isExplicit || wasInConfig || differsFromDefault) {
-            filtered[key] = value;
-        }
-    }
-    // Build content with comments
-    const lines = [
-        '{',
-        '  // npmglobalize configuration (JSON5 format - trailing commas OK)',
-        '  // Explicitly set values are preserved here',
-        ''
-    ];
-    // Add configured values
-    const entries = Object.entries(filtered);
-    if (entries.length > 0) {
-        entries.forEach(([key, value]) => {
-            const jsonValue = typeof value === 'string' ? `"${value}"` : JSON.stringify(value);
-            const comma = ','; // JSON5 allows trailing commas
-            // Add inline comment for clarity
-            let comment = '';
-            if (key === 'install')
-                comment = '  // Auto-install globally after publish (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')
-                comment = '  // Keep file: paths after publish';
-            else if (key === 'force')
-                comment = '  // Continue despite git errors';
-            else if (key === 'quiet')
-                comment = '  // Suppress npm warnings';
-            else if (key === 'verbose')
-                comment = '  // Show detailed output';
-            else if (key === 'gitVisibility')
-                comment = '  // private (default) or public';
-            else if (key === 'npmVisibility')
-                comment = '  // private (default) or public';
-            else if (key === 'bump')
-                comment = '  // patch (default), minor, or major';
-            else if (key === 'fix')
-                comment = '  // Auto-run npm audit fix';
-            else if (key === 'local')
-                comment = '  // Local install only (skip transform/publish)';
-            else if (key === 'noPublish')
-                comment = '  // Transform but don\'t publish';
-            else if (key === 'freeze')
-                comment = '  // Freeze node_modules (replace symlinks with real copies)';
-            else if (key === 'usePaths')
-                comment = '  // Resolve file: deps from sibling checkouts (set false for standalone packages)';
-            lines.push(`  "${key}": ${jsonValue}${comma}${comment}`);
-        });
-        lines.push('');
-    }
-    // Add commented reference for all options
-    lines.push('  // Defaults (omitted above):');
-    lines.push('  // "bump": "patch"              // Version bump: patch, minor, major');
-    lines.push('  // "install": false             // Auto-install globally after publish (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');
-    lines.push('  // "quiet": true                // Suppress npm warnings');
-    lines.push('  // "verbose": false             // Show detailed output');
-    lines.push('  // "gitVisibility": "private"   // Git repo: private or public');
-    lines.push('  // "npmVisibility": "private"   // npm package: private or public');
-    lines.push('  // "fix": false                 // Auto-run npm audit fix');
-    lines.push('  // "local": false              // Local install only (skip transform/publish)');
-    lines.push('  // "noPublish": false          // Transform but don\'t publish');
-    lines.push('  // "freeze": false              // Freeze node_modules (replace symlinks with real copies)');
-    lines.push('  // "usePaths": true              // Resolve file: deps from siblings; false = use latest npm version (standalone)');
-    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:');
-}
-//# sourceMappingURL=config.js.map

package/lib/deps.d.ts

@@ -1,42 +0,0 @@
-/**
- * npmglobalize dependency analysis, transformation, and restoration.
- * Handles file: ref discovery, workspace graphs, topological sorting,
- * and transforming file: deps to npm versions for publishing.
- */
-/** Get all file: dependencies from package.json */
-export declare function getFileRefs(pkg: any): Map<string, {
-    key: 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;
-    unpublished: Array<{
-        name: string;
-        version: string;
-        path: string;
-    }>;
-};
-/** Build and print a dependency tree of file: references.
- *  Recursively walks file: deps showing the full hierarchy with indentation. */
-export declare function printDepTree(baseDir: string, indent?: number, visited?: Set<string>): void;
-/** Restore file: dependencies from .dependencies */
-export declare function restoreDeps(pkg: any, verbose?: boolean): boolean;
-/** Check if .dependencies exist (already transformed) */
-export declare function hasBackup(pkg: any): boolean;
-//# sourceMappingURL=deps.d.ts.map

package/lib/deps.js

@@ -1,298 +0,0 @@
-/**
- * npmglobalize dependency analysis, transformation, and restoration.
- * Handles file: ref discovery, workspace graphs, topological sorting,
- * and transforming file: deps to npm versions for publishing.
- */
-import fs from 'fs';
-import path from 'path';
-import { spawnSafe, colors, DEP_KEYS } from './types.js';
-import { readPackageJson, isFileRef, resolveFilePath } from './config.js';
-import { checkVersionExists } from './npm.js';
-/** 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;
-}
-// ─── 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;
-}
-/** Check if a published npm package has broken deps (file: paths or unpublished transitive deps).
- *  Also checks local file: deps for unpublished versions. */
-function hasUnpublishedTransitiveDeps(packageName, pkg, baseDir, verbose) {
-    // Check 1: Does the npm-published version have file: paths in its deps?
-    try {
-        const result = spawnSafe('npm', ['view', packageName, 'dependencies', '--json'], {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            shell: true
-        });
-        if (result.status === 0 && result.stdout.trim()) {
-            const npmDeps = JSON.parse(result.stdout.trim());
-            for (const [depName, depValue] of Object.entries(npmDeps)) {
-                if (isFileRef(depValue)) {
-                    if (verbose) {
-                        console.log(colors.yellow(`    npm copy has file: dep ${depName} → ${depValue}`));
-                    }
-                    return true;
-                }
-            }
-        }
-    }
-    catch {
-        // Can't check npm — fall through to local check
-    }
-    // Check 2: Do local file: deps have unpublished versions?
-    for (const key of DEP_KEYS) {
-        if (!pkg[key])
-            continue;
-        for (const [depName, depValue] of Object.entries(pkg[key])) {
-            if (!isFileRef(depValue))
-                continue;
-            try {
-                const depPath = resolveFilePath(depValue, baseDir);
-                const depPkg = readPackageJson(depPath);
-                if (!checkVersionExists(depName, depPkg.version)) {
-                    if (verbose) {
-                        console.log(colors.yellow(`    transitive dep ${depName}@${depPkg.version} not on npm`));
-                    }
-                    return true;
-                }
-            }
-            catch {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/** Transform file: dependencies to npm versions */
-export function transformDeps(pkg, baseDir, verbose = false, forcePublish = false) {
-    let transformed = false;
-    const unpublished = [];
-    for (const key of DEP_KEYS) {
-        if (!pkg[key])
-            continue;
-        const dotKey = '.' + key;
-        // If .dependencies already exists, restore it and merge any new dependencies
-        if (pkg[dotKey]) {
-            // Save any new dependencies that aren't in .dependencies
-            const currentDeps = { ...pkg[key] };
-            // Restore .dependencies back to dependencies
-            pkg[key] = { ...pkg[dotKey] };
-            // Merge in any NEW dependencies that were added since transformation
-            for (const [name, value] of Object.entries(currentDeps)) {
-                if (!(name in pkg[dotKey])) {
-                    // This is a new dependency, add it
-                    pkg[key][name] = value;
-                    // Also add to .dependencies backup
-                    pkg[dotKey][name] = value;
-                    if (verbose) {
-                        console.log(`  Merged new dependency: ${name}`);
-                    }
-                }
-            }
-        }
-        const hasFileRefs = Object.values(pkg[key]).some(v => isFileRef(v));
-        if (!hasFileRefs)
-            continue;
-        // Backup original (or update existing backup with merged deps)
-        if (!pkg[dotKey]) {
-            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);
-                console.log(colors.blue(`  + ${name} → ${value}`));
-                try {
-                    const targetPkg = readPackageJson(targetPath);
-                    const targetVersion = targetPkg.version;
-                    const npmVersion = '^' + targetVersion;
-                    // Check if this version exists on npm (or if force publish)
-                    const versionExists = forcePublish ? false : checkVersionExists(name, targetVersion);
-                    if (!versionExists) {
-                        unpublished.push({ name, version: targetVersion, path: targetPath });
-                        if (forcePublish) {
-                            console.log(colors.yellow(`  ⟳ ${name}@${targetVersion} will be republished (--force-publish)`));
-                        }
-                        else {
-                            console.log(colors.red(`  ⚠ ${name}@${targetVersion} not found on npm (local: ${value})`));
-                        }
-                    }
-                    else {
-                        if (verbose) {
-                            console.log(colors.green(`  ✓ ${name}@${targetVersion} exists on npm`));
-                        }
-                        // Check transitive file: deps — if any are unpublished, this dep needs republishing
-                        if (hasUnpublishedTransitiveDeps(name, targetPkg, targetPath, verbose)) {
-                            unpublished.push({ name, version: targetVersion, path: targetPath });
-                            console.log(colors.yellow(`  ⟳ ${name}@${targetVersion} has unpublished transitive deps — will republish`));
-                        }
-                    }
-                    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, unpublished };
-}
-/** Build and print a dependency tree of file: references.
- *  Recursively walks file: deps showing the full hierarchy with indentation. */
-export function printDepTree(baseDir, indent = 0, visited = new Set()) {
-    const realDir = fs.realpathSync(baseDir);
-    if (visited.has(realDir))
-        return;
-    visited.add(realDir);
-    let pkg;
-    try {
-        pkg = readPackageJson(baseDir);
-    }
-    catch {
-        return;
-    }
-    for (const key of DEP_KEYS) {
-        if (!pkg[key])
-            continue;
-        // Use the backup (.dependencies) if present — it has the original file: refs
-        const deps = pkg['.' + key] || pkg[key];
-        for (const [name, value] of Object.entries(deps)) {
-            if (!isFileRef(value))
-                continue;
-            const prefix = ' '.repeat(indent * 2);
-            let targetPath;
-            let version = '?';
-            try {
-                targetPath = resolveFilePath(value, baseDir);
-                const targetPkg = readPackageJson(targetPath);
-                version = targetPkg.version || '?';
-            }
-            catch {
-                console.log(`${prefix}  ${name} → ${value} ${colors.red('(unresolvable)')}`);
-                continue;
-            }
-            const exists = checkVersionExists(name, version);
-            const marker = exists ? colors.green('✓') : colors.red('✗');
-            console.log(`${prefix}  ${marker} ${name}@${version} → ${value}`);
-            printDepTree(targetPath, indent + 1, visited);
-        }
-    }
-}
-/** 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]);
-}
-//# sourceMappingURL=deps.js.map