@bobfrankston/npmglobalize 1.0.209 → 1.0.211

package/lib.d.ts

@@ -578,6 +578,9 @@ export interface GitStatus {
     currentBranch: string;
     remoteBranch: string;
     isBehindRemote: boolean;
+    inProgressOp: string; /** 'rebase' | 'cherry-pick' | 'revert' | 'merge' | '' — a sequencer operation git never finished */
+    detachedFromBranch: string; /** Branch the unfinished operation started from (read from the rebase state's head-name) */
+    unmergedPaths: string[]; /** Files with unresolved conflict markers */
 }
 export declare function getGitStatus(cwd: string): GitStatus;
 /** Validate package.json for release */

package/lib.js

@@ -4738,7 +4738,10 @@ export function getGitStatus(cwd) {
         isDetachedHead: false,
         currentBranch: '',
         remoteBranch: '',
-        isBehindRemote: false
+        isBehindRemote: false,
+        inProgressOp: '',
+        detachedFromBranch: '',
+        unmergedPaths: []
     };
     // Check if git repo — walk up the directory tree to find the enclosing
     // .git, like git itself does. Previously this only looked for `.git/` at
@@ -4755,9 +4758,42 @@ export function getGitStatus(cwd) {
         return status;
     }
     status.isRepo = true;
-    // Check for merge conflicts
+    // 2026-09-01 14:5x EDT — Claude Code (Opus 5), at Bob's direction.
+    // Detect a sequencer operation git never finished. This is the usual cause of a
+    // detached HEAD in these trees: an npmglobalize run does `git pull --rebase`, the
+    // run is interrupted, and the rebase stops after applying its patches but before
+    // moving the branch ref — so HEAD sits on a real commit that belongs to no branch.
+    // Previously getGitStatus saw only "detached" and the caller printed a lecture about
+    // checking out a tag, which is not what happened and names the wrong branch.
     const mergeHead = path.join(gitDir, 'MERGE_HEAD');
-    status.hasMergeConflict = fs.existsSync(mergeHead);
+    const rebaseMerge = path.join(gitDir, 'rebase-merge');
+    const rebaseApply = path.join(gitDir, 'rebase-apply');
+    if (fs.existsSync(rebaseMerge) || fs.existsSync(rebaseApply)) {
+        status.inProgressOp = 'rebase';
+        for (const dir of [rebaseMerge, rebaseApply]) {
+            const headName = path.join(dir, 'head-name');
+            if (!fs.existsSync(headName))
+                continue;
+            status.detachedFromBranch = fs.readFileSync(headName, 'utf-8').trim().replace(/^refs\/heads\//, '');
+            break;
+        }
+    }
+    else if (fs.existsSync(path.join(gitDir, 'CHERRY_PICK_HEAD')))
+        status.inProgressOp = 'cherry-pick';
+    else if (fs.existsSync(path.join(gitDir, 'REVERT_HEAD')))
+        status.inProgressOp = 'revert';
+    else if (fs.existsSync(mergeHead))
+        status.inProgressOp = 'merge';
+    // Unresolved conflicts — the one state where the working tree is NOT authoritative,
+    // because it still holds conflict markers rather than the content Bob wants published.
+    try {
+        const unmerged = execSync('git diff --name-only --diff-filter=U', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        status.unmergedPaths = unmerged ? unmerged.split(/\r?\n/) : [];
+    }
+    catch (error) {
+        // Ignore - repo may have no commits yet
+    }
+    status.hasMergeConflict = status.unmergedPaths.length > 0;
     // Get branch info
     try {
         const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
@@ -4811,6 +4847,97 @@ export function getGitStatus(cwd) {
     }
     return status;
 }
+/** One-line `abbrev "subject"` description of a commit, for messages that must name what moved */
+function describeCommit(cwd, rev) {
+    // Arg array, not a command string: the format contains a space and %s expands to a
+    // commit subject that may contain quotes.
+    const result = runCommand('git', ['log', '-1', '--format=%h %s', rev], { cwd, silent: true });
+    if (!result.success)
+        return rev;
+    const line = result.output.trim().split(/\r?\n/)[0];
+    const space = line.indexOf(' ');
+    return space < 0 ? line : `${line.slice(0, space)} "${line.slice(space + 1)}"`;
+}
+/** Which branch a detached HEAD should be reattached to */
+function pickReattachBranch(cwd, status) {
+    // The branch the unfinished rebase was rebuilding is the one that was meant to end up here.
+    if (status.detachedFromBranch)
+        return status.detachedFromBranch;
+    // Otherwise the remote's own default branch, which is what a clone would have checked out.
+    try {
+        const originHead = execSync('git symbolic-ref --short refs/remotes/origin/HEAD', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        if (originHead.startsWith('origin/'))
+            return originHead.slice('origin/'.length);
+    }
+    catch (error) {
+        // No origin/HEAD — fall through
+    }
+    // Otherwise whichever conventional branch this repo actually has.
+    for (const name of ['main', 'master']) {
+        const exists = runCommand('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${name}`], { cwd, silent: true }).success
+            || runCommand('git', ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${name}`], { cwd, silent: true }).success;
+        if (exists)
+            return name;
+    }
+    return 'master';
+}
+/**
+ * 2026-09-01 14:5x EDT — Claude Code (Opus 5), at Bob's direction.
+ * Reattach a detached HEAD to its branch instead of printing a menu of git commands.
+ *
+ * Bob: "The local directory is authoritative so I want legacy mismatches just cleaned up."
+ * The working tree and the commit HEAD points at are what he wants published; a branch ref
+ * left behind by an interrupted run is bookkeeping, not content. So: drop the unfinished
+ * sequencer state, move the branch to this commit, and say exactly what moved and how to
+ * get the old tip back. The commit the branch moved off of stays in the reflog, and the
+ * message names it, so nothing is silently lost.
+ *
+ * Refuses only when the tree still has unresolved conflict markers — the one case where the
+ * working tree is not what Bob means by authoritative.
+ */
+async function reattachDetachedHead(cwd, status, dryRun) {
+    const branch = pickReattachBranch(cwd, status);
+    const head = describeCommit(cwd, 'HEAD');
+    const opLabel = status.inProgressOp ? `an unfinished ${status.inProgressOp}` : 'a checkout of a bare commit';
+    console.log('');
+    console.log(colors.yellow(`⚠ HEAD is not on a branch — left by ${opLabel}, at ${head}`));
+    let oldTip = '';
+    if (runCommand('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`], { cwd, silent: true }).success) {
+        const isAncestor = runCommand('git', ['merge-base', '--is-ancestor', branch, 'HEAD'], { cwd, silent: true }).success;
+        if (!isAncestor)
+            oldTip = describeCommit(cwd, branch);
+    }
+    if (dryRun) {
+        console.log(colors.dim(`  [dry-run] Would clear the ${status.inProgressOp || 'detached'} state and move branch ${branch} to ${head}`));
+        if (oldTip)
+            console.log(colors.dim(`  [dry-run] Branch ${branch} currently points at ${oldTip}, which is not in this history`));
+        return true;
+    }
+    if (status.inProgressOp && status.inProgressOp !== 'merge') {
+        // --quit drops the sequencer bookkeeping and leaves HEAD and the working tree alone,
+        // unlike --abort, which would throw away the commits the interrupted run produced.
+        const quit = await runCommandAsync('git', [status.inProgressOp === 'rebase' ? 'rebase' : status.inProgressOp, '--quit'], { cwd, silent: true });
+        if (!quit.success) {
+            console.error(colors.red(`✗ Could not clear the unfinished ${status.inProgressOp}: ${quit.stderr.trim()}`));
+            return false;
+        }
+        console.log(`  Cleared the unfinished ${status.inProgressOp} (its commits are kept)`);
+    }
+    const checkout = await runCommandAsync('git', ['checkout', '-B', branch], { cwd, silent: true });
+    if (!checkout.success) {
+        console.error(colors.red(`✗ Could not move branch ${branch} to ${head}: ${checkout.stderr.trim()}`));
+        return false;
+    }
+    console.log(colors.green(`✓ On branch ${branch} at ${head}`));
+    if (oldTip) {
+        console.log(`  Branch ${branch} previously pointed at ${oldTip}, which is not in this history.`);
+        console.log(colors.dim(`  To put ${branch} back there: git reset --hard ${oldTip.split(' ')[0]}`));
+    }
+    if (runCommand('git', ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${branch}`], { cwd, silent: true }).success)
+        runCommand('git', ['branch', `--set-upstream-to=origin/${branch}`, branch], { cwd, silent: true });
+    console.log('');
+    return true;
+}
 /** Validate package.json for release */
 export function validatePackageJson(pkg) {
     const errors = [];
@@ -6371,70 +6498,37 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     let currentGitStatus = getGitStatus(cwd);
     // Validate git state
     if (currentGitStatus.hasMergeConflict) {
-        console.error(colors.red('ERROR: Merge conflict detected. Resolve before releasing.'));
+        console.error(colors.red(`ERROR: ${currentGitStatus.unmergedPaths.length} file(s) still have unresolved conflicts. Resolve before releasing:`));
+        for (const file of currentGitStatus.unmergedPaths)
+            console.error(`  ${file}`);
         return false;
     }
-    if (currentGitStatus.isDetachedHead && !force) {
-        if (conform && !noPublish) {
-            // Conform already happened earlier, just exit gracefully
-            console.log('');
-            console.log(colors.green('✓ Files have been updated successfully!'));
-            console.log('  • .gitignore updated');
-            console.log('  • .npmignore updated');
-            console.log('  • .gitattributes created/updated (LF line endings)');
-            console.log('  • Git configured: core.autocrlf=false, core.eol=lf');
-            console.log('');
-            console.log(colors.yellow('ℹ What is "Detached HEAD"?'));
-            console.log('  Your git repository is not on a branch (master, main, etc.)');
-            console.log('  This happens after checking out a specific commit or tag.');
-            console.log('  Publishing requires being on a branch so git can track changes.');
-            console.log('');
-            console.log(colors.yellow('✓ Good news: Your files are already fixed!'));
-            console.log(colors.yellow('  You don\'t need to run --conform again.'));
-            console.log('');
-            console.log(colors.yellow('To publish, merge back to your branch:'));
-            console.log('  git checkout -B master    \x1b[2m# moves master to current commit\x1b[0m');
-            console.log('  npmglobalize              \x1b[2m# will now work normally\x1b[0m');
-            console.log('');
-            console.log(colors.yellow('Or if you haven\'t made commits yet:'));
-            console.log('  git checkout master       \x1b[2m# just switch back\x1b[0m');
-            console.log('');
-            return true; // Success - conform was completed
+    // 2026-09-01 14:5x EDT — Claude Code (Opus 5), at Bob's direction.
+    // A detached HEAD used to be a hard stop with a menu of git commands to type — and the
+    // commands named "master" whether or not the repo had one. It is a bookkeeping mismatch,
+    // not a content problem: the working tree is authoritative, so repair it and carry on.
+    if (currentGitStatus.isDetachedHead) {
+        if (!await reattachDetachedHead(cwd, currentGitStatus, dryRun))
+            return false;
+        currentGitStatus = getGitStatus(cwd);
+    }
+    // Reaching this means HEAD is still off a branch after the reattach above. A dry run
+    // changes nothing by design, so it lands here and is expected; anything else is a real
+    // failure and the reattach already printed why.
+    if (currentGitStatus.isDetachedHead && !dryRun) {
+        if (noPublish) {
+            console.log(colors.yellow('Note: HEAD is not on a branch (this run does not publish)'));
         }
-        else if (noPublish) {
-            // Just doing non-publish operations, detached HEAD is fine
-            console.log(colors.yellow('Note: Detached HEAD state (no publishing will occur)'));
+        else if (force) {
+            console.log(colors.yellow('⚠ Publishing with HEAD off a branch (-force): the version tag and commits'));
+            console.log(colors.yellow('  will not be reachable from any branch, so git push will not carry them.'));
         }
         else {
-            console.log('');
-            console.error(colors.red('ERROR: Cannot publish from Detached HEAD state'));
-            console.log('');
-            console.log(colors.yellow('ℹ What is "Detached HEAD"?'));
-            console.log('  Your git repository is not on a branch (master, main, etc.)');
-            console.log('  This happens after checking out a specific commit or tag.');
-            console.log('  Publishing requires being on a branch so git can track changes.');
-            console.log('');
-            console.log(colors.yellow('To fix this (if you have commits to keep):'));
-            console.log('  git checkout -B master    \x1b[2m# moves master branch to current commit\x1b[0m');
-            console.log('  npmglobalize              \x1b[2m# will now work\x1b[0m');
-            console.log('');
-            console.log(colors.yellow('Or if you haven\'t made commits (safe to discard):'));
-            console.log('  git checkout master       \x1b[2m# just switch back to branch\x1b[0m');
-            console.log('  npmglobalize              \x1b[2m# will now work\x1b[0m');
-            console.log('');
-            console.log(colors.yellow('Or force publish anyway (risky):'));
-            console.log('  npmglobalize --force      \x1b[2m# proceeds despite detached HEAD\x1b[0m');
-            console.log('');
+            console.error(colors.red('ERROR: HEAD is still not on a branch, so there is nothing for git push to advance.'));
+            console.error(`  Put a branch on the current commit and rerun: git checkout -B ${pickReattachBranch(cwd, currentGitStatus)}`);
             return false;
         }
     }
-    if (currentGitStatus.isDetachedHead && force) {
-        console.log('');
-        console.log(colors.yellow('⚠ Warning: Publishing from Detached HEAD state (--force)'));
-        console.log('  This means you\'re not on a branch. The published commits may be');
-        console.log('  hard to track. Consider: git checkout master && git merge HEAD');
-        console.log('');
-    }
     // Check if local branch is behind remote
     if (currentGitStatus.isBehindRemote && !dryRun) {
         console.log(colors.yellow('Local branch is behind remote.'));

package/package.json

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