@bobfrankston/npmglobalize 1.0.24 → 1.0.26

package/README.md

@@ -19,6 +19,9 @@ cd your-package
 npmglobalize              # Transform + publish (patch version)
 npmglobalize --minor      # Bump minor version
 npmglobalize --major      # Bump major version
+
+# Or run from anywhere with a path
+npmglobalize y:\path\to\your-package
 ```
 
 ## Key Features
@@ -110,6 +113,24 @@ npmglobalize -np          # --nopublish (formerly --apply)
 npmglobalize --cleanup    # Restore original file: references
 ```
 
+### 🔧 Git Integration & Error Recovery
+
+**Automatic tag conflict resolution**:
+```bash
+npmglobalize --fix-tags   # Auto-fix version/tag mismatches
+```
+
+When a previous publish fails, git tags may conflict with package.json version. The `--fix-tags` option (or automatic detection) will clean up these conflicts.
+
+**Automatic rebase** when local is behind remote:
+```bash
+npmglobalize --rebase     # Auto-rebase if behind remote
+```
+
+For single-developer projects, this safely pulls remote changes before publishing.
+
+**Note:** This tool is designed for single-developer, single-branch workflows where automatic rebase and tag cleanup are safe operations.
+
 ## Command Reference
 
 ### Release Options
@@ -160,6 +181,8 @@ npmglobalize --cleanup    # Restore original file: references
 --verbose       Show detailed output
 --conform       Update .gitignore/.npmignore to best practices
 --asis          Skip ignore file checks
+--fix-tags      Automatically fix version/tag mismatches
+--rebase        Automatically rebase if local is behind remote
 --help, -h      Show help
 --version, -v   Show version
 ```
@@ -244,6 +267,12 @@ When publishing file: dependencies, checks if each version exists on npm:
 # Basic release
 npmglobalize
 
+# Run on a different project
+npmglobalize y:\dev\myproject
+
+# Auto-fix tag conflicts and rebase
+npmglobalize --fix-tags --rebase
+
 # Release with updates and security fixes
 npmglobalize --update-deps --fix
 

package/cli.js

@@ -52,6 +52,7 @@ Other Options:
   --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
+  --rebase        Automatically rebase if local is behind remote
   --help, -h      Show this help
   --version, -v   Show version number
 
@@ -60,6 +61,7 @@ Examples:
   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 --rebase              Auto-rebase if behind remote
   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)
@@ -181,6 +183,9 @@ function parseArgs(args) {
             case '--fix-tags':
                 options.fixTags = true;
                 break;
+            case '--rebase':
+                options.rebase = true;
+                break;
             case '--update-deps':
                 options.updateDeps = true;
                 break;

package/lib.d.ts

@@ -47,6 +47,8 @@ export interface GlobalizeOptions {
     fix?: boolean;
     /** Automatically fix version/tag mismatches */
     fixTags?: boolean;
+    /** Automatically rebase if local is behind remote */
+    rebase?: boolean;
 }
 /** Read and parse package.json from a directory */
 export declare function readPackageJson(dir: string): any;
@@ -99,6 +101,12 @@ export declare function getLatestGitTag(cwd: string): string | null;
 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 */
@@ -126,6 +134,7 @@ export interface GitStatus {
     isDetachedHead: boolean;
     currentBranch: string;
     remoteBranch: string;
+    isBehindRemote: boolean;
 }
 export declare function getGitStatus(cwd: string): GitStatus;
 /** Validate package.json for release */
@@ -141,6 +150,8 @@ export declare function runNpmAudit(cwd: string, fix?: boolean, verbose?: boolea
     report: string;
     hasVulnerabilities: boolean;
 };
+/** Get the version of npmglobalize itself */
+export declare function getToolVersion(): string;
 export declare function globalize(cwd: string, options?: GlobalizeOptions): Promise<boolean>;
 declare const _default: {
     globalize: typeof globalize;

package/lib.js

@@ -7,6 +7,7 @@ import { execSync, spawnSync } from 'child_process';
 import readline from 'readline';
 import libversion from 'libnpmversion';
 import JSON5 from 'json5';
+import { fileURLToPath } from 'url';
 /** ANSI color codes */
 const colors = {
     red: (text) => `\x1b[31m${text}\x1b[0m`,
@@ -388,38 +389,81 @@ export function deleteGitTag(cwd, tag) {
         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 expectedTag = `v${pkgVersion}`;
-    const latestTag = getLatestGitTag(cwd);
-    // Check if the expected tag exists but doesn't match package.json
-    if (gitTagExists(cwd, expectedTag)) {
-        // Tag exists and matches - no issue
+    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(`Tag ${expectedTag} exists and matches package.json version`);
+            console.log(`No conflicting tags found (package.json is at v${pkgVersion})`);
         }
         return false;
     }
-    // Check if there's a tag that's ahead of package.json version
-    if (latestTag && latestTag !== expectedTag) {
-        console.log(colors.yellow(`\nVersion mismatch detected:`));
-        console.log(`  package.json version: ${pkgVersion}`);
-        console.log(`  Latest git tag: ${latestTag}`);
-        console.log(colors.yellow('Deleting conflicting tag...'));
-        if (deleteGitTag(cwd, latestTag)) {
-            console.log(colors.green(`✓ Deleted tag ${latestTag}`));
-            return true;
+    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 ${latestTag}`));
-            return false;
+            console.error(colors.red(`  ✗ Failed to delete tag ${tag}`));
         }
     }
-    return false;
+    return deletedAny;
 }
 /** Run a command and return success status */
 export function runCommand(cmd, args, options = {}) {
@@ -486,7 +530,8 @@ export function getGitStatus(cwd) {
         hasMergeConflict: false,
         isDetachedHead: false,
         currentBranch: '',
-        remoteBranch: ''
+        remoteBranch: '',
+        isBehindRemote: false
     };
     // Check if git repo
     const gitDir = path.join(cwd, '.git');
@@ -535,6 +580,18 @@ export function getGitStatus(cwd) {
         catch (error) {
             // Ignore - might not have tracking branch
         }
+        // Check if local is behind remote
+        try {
+            const behind = execSync(`git log HEAD..origin/${status.currentBranch} --oneline 2>nul`, {
+                cwd,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore']
+            }).trim();
+            status.isBehindRemote = behind.length > 0;
+        }
+        catch (error) {
+            // Ignore - might not have tracking branch
+        }
     }
     return status;
 }
@@ -995,9 +1052,25 @@ export function runNpmAudit(cwd, fix = false, verbose = false) {
         hasVulnerabilities
     };
 }
+/** Get the version of npmglobalize itself */
+export function getToolVersion() {
+    try {
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.join(__dirname, 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return pkg.version || 'unknown';
+    }
+    catch (error) {
+        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
-    forcePublish = false, fix = false, fixTags = false } = options;
+    forcePublish = false, fix = false, fixTags = false, rebase = false } = options;
+    // Show tool version
+    const toolVersion = getToolVersion();
+    console.log(colors.italic(`npmglobalize v${toolVersion}`));
+    console.log('');
     // Check ignore files first (unless cleanup mode)
     if (!cleanup && !asis) {
         const checkResult = checkIgnoreFiles(cwd, { conform, asis, verbose });
@@ -1120,6 +1193,38 @@ export async function globalize(cwd, options = {}) {
     if (currentGitStatus.isDetachedHead && force) {
         console.log(colors.yellow('Warning: Detached HEAD state - continuing with --force'));
     }
+    // Check if local branch is behind remote
+    if (currentGitStatus.isBehindRemote && !dryRun) {
+        console.log(colors.yellow('Local branch is behind remote.'));
+        if (rebase) {
+            console.log('Rebasing local changes (--rebase)...');
+            const rebaseResult = runCommand('git', ['pull', '--rebase'], { cwd, silent: false });
+            if (!rebaseResult.success) {
+                console.error(colors.red('ERROR: Rebase failed.'));
+                console.error('You may need to resolve conflicts manually.');
+                if (!force) {
+                    return false;
+                }
+                console.log(colors.yellow('Continuing with --force...'));
+            }
+            else {
+                console.log(colors.green('✓ Successfully rebased'));
+            }
+        }
+        else {
+            console.error(colors.red('ERROR: Local branch is behind remote.'));
+            console.error(colors.yellow('Your local repository needs to be updated before publishing.'));
+            console.error('');
+            console.error('To fix this:');
+            console.error(colors.yellow('  1. Run: npmglobalize --rebase (automatic)'));
+            console.error(colors.yellow('  2. Or manually: git pull --rebase'));
+            console.error('');
+            if (!force) {
+                return false;
+            }
+            console.log(colors.yellow('Continuing with --force (git push may fail)...'));
+        }
+    }
     // Read package.json
     const pkg = readPackageJson(cwd);
     // Pre-flight check: fix version/tag mismatches if requested or if we detect issues
@@ -1408,7 +1513,21 @@ export async function globalize(cwd, options = {}) {
             }
             // Check for specific error conditions
             const stderrLower = (error.stderr || '').toLowerCase();
-            if (stderrLower.includes('tag') && stderrLower.includes('already exists')) {
+            const stdoutLower = (error.stdout || '').toLowerCase();
+            const combinedOutput = stderrLower + ' ' + stdoutLower;
+            if (combinedOutput.includes('non-fast-forward') || combinedOutput.includes('rejected') && combinedOutput.includes('behind')) {
+                console.error(colors.yellow('\nYour local branch is behind the remote.'));
+                console.error(colors.yellow('This usually means changes were pushed from another location.'));
+                console.error(colors.yellow('\nTo fix this:'));
+                console.error('  1. Pull remote changes: git pull --rebase');
+                console.error('  2. Then run npmglobalize again');
+                console.error(colors.yellow('\nOr to force push (use with caution):'));
+                console.error('  git push --force-with-lease');
+                if (!force) {
+                    return false;
+                }
+            }
+            else 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;
@@ -1431,6 +1550,31 @@ export async function globalize(cwd, options = {}) {
                         }
                         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;
                             }

package/package.json

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