@bobfrankston/npmglobalize 1.0.23 → 1.0.25

package/cli.js

@@ -10,7 +10,10 @@ function printHelp() {
     console.log(`
 npmglobalize - Transform file: dependencies to npm versions for publishing
 
-Usage: npmglobalize [options]
+Usage: npmglobalize [path] [options]
+
+Arguments:
+  path            Path to the project directory (default: current directory)
 
 Release Options:
   --patch         Bump patch version (default)
@@ -48,12 +51,15 @@ Other Options:
   --verbose       Show detailed output
   --conform       Update .gitignore/.npmignore to best practices
   --asis          Skip ignore file checks (or set "asis": true in .globalize.json5)
+  --fix-tags      Automatically fix version/tag mismatches
   --help, -h      Show this help
   --version, -v   Show version number
 
 Examples:
   npmglobalize                       Transform + publish (auto-publishes file: deps)
+  npmglobalize y:\\path\\to\\project  Run on a different project directory
   npmglobalize --minor               Release with minor version bump
+  npmglobalize --fix-tags            Fix version/tag mismatches before running
   npmglobalize --update-deps         Safe updates (minor/patch only)
   npmglobalize --update-major        Allow breaking changes (major updates)
   npmglobalize -npd                  Skip auto-publishing file: deps (use with caution)
@@ -73,6 +79,7 @@ function parseArgs(args) {
         error: ''
     };
     const unrecognized = [];
+    const positional = [];
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         switch (arg) {
@@ -171,6 +178,9 @@ function parseArgs(args) {
             case '--asis':
                 options.asis = true;
                 break;
+            case '--fix-tags':
+                options.fixTags = true;
+                break;
             case '--update-deps':
                 options.updateDeps = true;
                 break;
@@ -198,12 +208,21 @@ function parseArgs(args) {
                 if (arg.startsWith('-')) {
                     unrecognized.push(arg);
                 }
+                else {
+                    positional.push(arg);
+                }
                 break;
         }
     }
     if (unrecognized.length > 0) {
         options.error = `Unrecognized arguments: ${unrecognized.join(', ')}`;
     }
+    if (positional.length > 1) {
+        options.error = `Too many positional arguments. Expected at most 1 (path), got ${positional.length}`;
+    }
+    else if (positional.length === 1) {
+        options.targetPath = positional[0];
+    }
     return options;
 }
 export async function main() {
@@ -226,7 +245,19 @@ export async function main() {
         console.error('Run with --help for usage.');
         process.exit(1);
     }
-    const cwd = process.cwd();
+    let cwd = process.cwd();
+    // Use target path if provided
+    if (cliOptions.targetPath) {
+        cwd = path.resolve(cwd, cliOptions.targetPath);
+        if (!fs.existsSync(cwd)) {
+            console.error(`Error: Path does not exist: ${cwd}`);
+            process.exit(1);
+        }
+        if (!fs.statSync(cwd).isDirectory()) {
+            console.error(`Error: Not a directory: ${cwd}`);
+            process.exit(1);
+        }
+    }
     // Load config file and merge with CLI options (CLI takes precedence)
     const configOptions = readConfig(cwd);
     const options = { ...configOptions, ...cliOptions };

package/lib.d.ts

@@ -45,6 +45,8 @@ export interface GlobalizeOptions {
     forcePublish?: boolean;
     /** Run npm audit and fix vulnerabilities */
     fix?: boolean;
+    /** Automatically fix version/tag mismatches */
+    fixTags?: boolean;
 }
 /** Read and parse package.json from a directory */
 export declare function readPackageJson(dir: string): any;
@@ -91,6 +93,20 @@ export declare function transformDeps(pkg: any, baseDir: string, verbose?: boole
 export declare function restoreDeps(pkg: any, verbose?: boolean): boolean;
 /** Check if .dependencies exist (already transformed) */
 export declare function hasBackup(pkg: any): boolean;
+/** Get the latest git tag (if any) */
+export declare function getLatestGitTag(cwd: string): string | null;
+/** Check if a git tag exists */
+export declare function gitTagExists(cwd: string, tag: string): boolean;
+/** Delete a git tag */
+export declare function deleteGitTag(cwd: string, tag: string): boolean;
+/** Get all git tags */
+export declare function getAllGitTags(cwd: string): string[];
+/** Parse version from tag (e.g., 'v1.2.3' -> [1, 2, 3]) */
+export declare function parseVersionTag(tag: string): number[] | null;
+/** Compare two version arrays (returns -1 if a < b, 0 if equal, 1 if a > b) */
+export declare function compareVersions(a: number[], b: number[]): number;
+/** Fix version/tag mismatches */
+export declare function fixVersionTagMismatch(cwd: string, pkg: any, verbose?: boolean): boolean;
 /** Run a command and return success status */
 export declare function runCommand(cmd: string, args: string[], options?: {
     silent?: boolean;

package/lib.js

@@ -343,6 +343,127 @@ export function restoreDeps(pkg, verbose = false) {
 export function hasBackup(pkg) {
     return DEP_KEYS.some(key => pkg['.' + key]);
 }
+/** Get the latest git tag (if any) */
+export function getLatestGitTag(cwd) {
+    try {
+        const result = spawnSync('git', ['describe', '--tags', '--abbrev=0'], {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            cwd
+        });
+        if (result.status === 0 && result.stdout) {
+            return result.stdout.trim();
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/** Check if a git tag exists */
+export function gitTagExists(cwd, tag) {
+    try {
+        const result = spawnSync('git', ['tag', '-l', tag], {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            cwd
+        });
+        return result.status === 0 && result.stdout.trim() === tag;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/** Delete a git tag */
+export function deleteGitTag(cwd, tag) {
+    try {
+        const result = spawnSync('git', ['tag', '-d', tag], {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            cwd
+        });
+        return result.status === 0;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/** Get all git tags */
+export function getAllGitTags(cwd) {
+    try {
+        const result = spawnSync('git', ['tag', '-l'], {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            cwd
+        });
+        if (result.status === 0 && result.stdout) {
+            return result.stdout.trim().split('\n').filter(t => t.trim());
+        }
+        return [];
+    }
+    catch (error) {
+        return [];
+    }
+}
+/** Parse version from tag (e.g., 'v1.2.3' -> [1, 2, 3]) */
+export function parseVersionTag(tag) {
+    const match = tag.match(/^v?(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return null;
+    return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3])];
+}
+/** Compare two version arrays (returns -1 if a < b, 0 if equal, 1 if a > b) */
+export function compareVersions(a, b) {
+    for (let i = 0; i < 3; i++) {
+        if (a[i] < b[i])
+            return -1;
+        if (a[i] > b[i])
+            return 1;
+    }
+    return 0;
+}
+/** Fix version/tag mismatches */
+export function fixVersionTagMismatch(cwd, pkg, verbose = false) {
+    const pkgVersion = pkg.version;
+    if (!pkgVersion) {
+        return false; // No version in package.json
+    }
+    const currentVersion = parseVersionTag(pkgVersion);
+    if (!currentVersion) {
+        console.error(colors.yellow(`Warning: Could not parse package.json version: ${pkgVersion}`));
+        return false;
+    }
+    const allTags = getAllGitTags(cwd);
+    const tagsToDelete = [];
+    // Find all tags that are >= current package.json version
+    for (const tag of allTags) {
+        const tagVersion = parseVersionTag(tag);
+        if (tagVersion && compareVersions(tagVersion, currentVersion) >= 0) {
+            tagsToDelete.push(tag);
+        }
+    }
+    if (tagsToDelete.length === 0) {
+        if (verbose) {
+            console.log(`No conflicting tags found (package.json is at v${pkgVersion})`);
+        }
+        return false;
+    }
+    console.log(colors.yellow(`\nVersion/tag mismatch detected:`));
+    console.log(`  package.json version: ${pkgVersion}`);
+    console.log(`  Conflicting tags found: ${tagsToDelete.join(', ')}`);
+    console.log(colors.yellow('Deleting conflicting tags...'));
+    let deletedAny = false;
+    for (const tag of tagsToDelete) {
+        if (deleteGitTag(cwd, tag)) {
+            console.log(colors.green(`  ✓ Deleted tag ${tag}`));
+            deletedAny = true;
+        }
+        else {
+            console.error(colors.red(`  ✗ Failed to delete tag ${tag}`));
+        }
+    }
+    return deletedAny;
+}
 /** Run a command and return success status */
 export function runCommand(cmd, args, options = {}) {
     const { silent = false, cwd, shell = false } = options;
@@ -919,7 +1040,7 @@ export function runNpmAudit(cwd, fix = false, verbose = false) {
 }
 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
-    forcePublish = false, fix = false } = options;
+    forcePublish = false, fix = false, fixTags = false } = options;
     // Check ignore files first (unless cleanup mode)
     if (!cleanup && !asis) {
         const checkResult = checkIgnoreFiles(cwd, { conform, asis, verbose });
@@ -1044,6 +1165,13 @@ export async function globalize(cwd, options = {}) {
     }
     // Read package.json
     const pkg = readPackageJson(cwd);
+    // Pre-flight check: fix version/tag mismatches if requested or if we detect issues
+    if (fixTags || !dryRun) {
+        const hadMismatch = fixVersionTagMismatch(cwd, pkg, verbose);
+        if (hadMismatch && !fixTags) {
+            console.log(colors.yellow('(Use --fix-tags to automatically fix tag issues in the future)'));
+        }
+    }
     // Auto-add repository field if git exists but field is missing
     if (currentGitStatus.isRepo && currentGitStatus.hasRemote && !pkg.repository) {
         try {
@@ -1321,8 +1449,74 @@ export async function globalize(cwd, options = {}) {
             if (verbose && error.stack) {
                 console.error('  Stack trace:', error.stack);
             }
-            // Try to provide more context
-            if (error.message?.includes('unknown git error')) {
+            // Check for specific error conditions
+            const stderrLower = (error.stderr || '').toLowerCase();
+            if (stderrLower.includes('tag') && stderrLower.includes('already exists')) {
+                // Extract tag name if possible
+                const tagMatch = error.stderr?.match(/tag '([^']+)' already exists/);
+                const tagName = tagMatch ? tagMatch[1] : null;
+                console.error(colors.yellow('\nThe version tag already exists in git.'));
+                console.error(colors.yellow('This usually means a previous version bump succeeded but publish failed.'));
+                // Attempt automatic fix
+                if (tagName) {
+                    console.log(colors.yellow('Attempting automatic fix...'));
+                    if (deleteGitTag(cwd, tagName)) {
+                        console.log(colors.green(`✓ Deleted conflicting tag ${tagName}`));
+                        console.log('Retrying version bump...');
+                        // Retry the version bump
+                        try {
+                            const newVersion = await libversion(bump, {
+                                path: cwd
+                            });
+                            console.log(colors.green(`Version bumped to ${newVersion}`));
+                            // Success! Continue with the rest of the process
+                            // Don't return here - let it fall through to publish
+                        }
+                        catch (retryError) {
+                            console.error(colors.red('ERROR: Retry failed:'), retryError.message);
+                            // Show retry error details
+                            if (retryError.stderr || retryError.stdout || retryError.code) {
+                                if (retryError.stderr)
+                                    console.error('  stderr:', retryError.stderr);
+                                if (retryError.stdout)
+                                    console.error('  stdout:', retryError.stdout);
+                                if (retryError.code)
+                                    console.error('  exit code:', retryError.code);
+                            }
+                            // Check if it's the same tag issue again
+                            const retryStderrLower = (retryError.stderr || '').toLowerCase();
+                            if (retryStderrLower.includes('tag') && retryStderrLower.includes('already exists')) {
+                                const retryTagMatch = retryError.stderr?.match(/tag '([^']+)' already exists/);
+                                const retryTagName = retryTagMatch ? retryTagMatch[1] : null;
+                                console.error(colors.red('\\nAnother tag conflict detected!'));
+                                console.error(colors.yellow('This suggests package.json version may have been bumped previously.'));
+                                console.error(colors.yellow('\\nSuggestions:'));
+                                if (retryTagName) {
+                                    console.error(`  1. Delete the tag and reset package.json:`);
+                                    console.error(`     git tag -d ${retryTagName}`);
+                                    console.error(`     (Then manually adjust package.json version if needed)`);
+                                }
+                                console.error('  2. Check git log and package.json history for version mismatches');
+                                console.error('  3. Run: git tag -l | sort -V to see all version tags');
+                            }
+                            if (!force) {
+                                return false;
+                            }
+                        }
+                    }
+                    else {
+                        console.error(colors.red(`✗ Failed to delete tag ${tagName}`));
+                        console.error(colors.yellow('\nManual fix required:'));
+                        console.error(`  1. Delete the tag: git tag -d ${tagName}`);
+                        console.error(`  2. Or push and reset: git push origin ${tagName} && git tag -d ${tagName}`);
+                        console.error('  3. Or manually edit package.json to match the existing tag version');
+                        if (!force) {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else if (error.message?.includes('unknown git error')) {
                 console.error(colors.yellow('\nPossible causes:'));
                 console.error('  • Git hooks (pre-commit, commit-msg) might be failing');
                 console.error('  • GPG signing might be required but not configured');

package/package.json

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