@bobfrankston/npmglobalize 1.0.24 → 1.0.25

package/lib.d.ts

@@ -99,6 +99,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 */

package/lib.js

@@ -388,38 +388,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 = {}) {
@@ -1431,6 +1474,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.25",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",