@bobfrankston/npmglobalize 1.0.178 → 1.0.179

package/README.md

@@ -244,6 +244,49 @@ npmglobalize -git public     # Makes the GitHub repo public (with confirmation)
 npmglobalize -git private    # Makes the GitHub repo private
 ```
 
+### Missing local `.git` (adopt vs fresh init)
+
+When npmglobalize runs in a directory with no `.git`, it first checks for a
+reachable `repository.url` in `package.json`. If found, it offers two paths:
+
+```
+How would you like to set up git?
+  1) Adopt history from existing remote (recommended)
+  2) Initialize fresh git repository
+  a) Adopt ALL (don't ask again for remaining deps)
+  3) Use local install only (skip git/publish)
+  4) Abort
+```
+
+**Adopt** runs:
+
+```bash
+git init
+git remote add origin <package.json repository.url>
+git fetch origin
+# Point HEAD at origin/<defaultBranch> without touching the working tree
+git update-ref refs/heads/<branch> origin/<branch>
+git symbolic-ref HEAD refs/heads/<branch>
+git reset                       # mixed: refresh index, keep working tree
+```
+
+After adoption, your local files appear as **uncommitted changes on top of the
+remote's HEAD** — `git status` shows the drift, and npmglobalize's normal flow
+will commit them on the next publish. **No force-push is required**, and the
+remote's history is preserved.
+
+If the remote is not reachable (no `repository` field, network/auth failure,
+deleted repo), the original "Initialize fresh git repository" prompt is shown
+instead.
+
+CLI flags:
+
+- `-init` — auto path; adopts if a reachable remote is found, otherwise falls
+  back to fresh `git init` + `gh repo create`.
+- `-adopt` — **strict**: aborts if no reachable remote in `package.json.repository`.
+  Use this when you want to be sure no new GitHub repo is created (e.g. in
+  scripts, or when re-attaching a tree of packages to existing repos).
+
 When initializing a new repository with `--init`, npmglobalize automatically sets up:
 
 **File structure** (per programming.md standards):
@@ -379,7 +422,11 @@ Workspace mode is auto-detected when run from a root with `"private": true` and
 ### Other Options
 ```
 -init           Initialize git/npm if needed (creates .gitignore, .npmignore,
-                .gitattributes, and configures git for LF line endings)
+                .gitattributes, and configures git for LF line endings).
+                If package.json.repository.url is reachable, adopts its
+                history instead of creating a fresh repo.
+-adopt          Strict adopt: require a reachable git remote in
+                package.json.repository. Abort if probe fails. Skips prompt.
 -force          Continue despite git errors
 -dry-run        Preview what would happen
 -quiet          Suppress npm warnings (default)
@@ -625,9 +672,12 @@ npmglobalize -local
 # Restore original file: references
 npmglobalize -cleanup
 
-# Initialize new git repo + release
+# Initialize git (adopt existing remote if reachable, else fresh) + release
 npmglobalize -init
 
+# Strict adopt: re-attach to remote in package.json.repository (or abort)
+npmglobalize -adopt
+
 # Migrate package.json scripts to use npmglobalize
 npmglobalize -package
 

package/cli.js

@@ -82,7 +82,10 @@ Workspace Options:
   -continue-on-error    Continue if a package fails in workspace mode
 
 Other Options:
-  -init           Initialize git/npm if needed
+  -init           Initialize git/npm if needed (auto-adopts existing remote
+                  in package.json.repository if reachable, else fresh init)
+  -adopt          Strict adopt: require a reachable git remote in
+                  package.json.repository. Abort if probe fails. Skips prompt.
   -force          Continue despite git errors
   -dry-run        Preview what would happen
   -quiet          Suppress npm warnings (default)
@@ -117,7 +120,8 @@ Examples:
   npmglobalize -local -wsl           Local install on Windows and WSL
   npmglobalize -np                   Just transform, no publish (remembered in config)
   npmglobalize -cleanup              Restore original dependencies
-  npmglobalize -init                 Initialize new git repo + release
+  npmglobalize -init                 Initialize git (adopt existing remote if any) + release
+  npmglobalize -adopt                Adopt history from package.json.repository (abort if no remote)
   npmglobalize -dry-run              Preview what would happen
   npmglobalize -package              Migrate scripts to use npmglobalize
 
@@ -222,6 +226,9 @@ function parseArgs(args) {
             case '-init':
                 options.init = true;
                 break;
+            case '-adopt':
+                options.adopt = true;
+                break;
             case '-git':
                 i++;
                 if (args[i] === 'private' || args[i] === 'public') {

package/lib.d.ts

@@ -115,6 +115,10 @@ export interface GlobalizeOptions {
     cleanNestedModules?: boolean;
     /** Internal: auto-initialize git repos without prompting (user chose "all") */
     autoInit?: boolean;
+    /** Strict adopt: require that a reachable git remote exists in
+     *  package.json.repository. Aborts (rather than creating a fresh repo) if
+     *  the probe fails. Skips the no-git prompt. */
+    adopt?: boolean;
     /** Internal: signals this call is from workspace orchestrator */
     /** Skip the upfront dep-graph prescan */
     noPrescan?: boolean;
@@ -382,6 +386,10 @@ export declare function confirm(message: string, defaultYes?: boolean): Promise<
 export declare function promptText(message: string, defaultValue?: string): Promise<string>;
 /** Prompt user for multiple choice */
 export declare function promptChoice(message: string, choices: string[]): Promise<string | null>;
+/** Initialize a local git repo by adopting history from an existing remote.
+ *  Preserves the working tree — local files appear as uncommitted changes
+ *  on top of the remote's HEAD. No force-push is required. */
+export declare function adoptExistingRemote(cwd: string, repoUrl: string, defaultBranch: string, dryRun: boolean): Promise<boolean>;
 /** Initialize git repository */
 export declare function initGit(cwd: string, visibility: 'private' | 'public', dryRun: boolean, allowTs?: boolean): Promise<boolean>;
 /** Main globalize function */

package/lib.js

@@ -3045,6 +3045,105 @@ function ensureGitattributes(cwd) {
         console.log(colors.green('  ✓ .gitattributes created (LF line endings)'));
     }
 }
+/** Extract a git remote URL from package.json's repository field, normalised */
+function getPackageRepoUrl(pkg) {
+    if (!pkg || !pkg.repository)
+        return null;
+    const raw = typeof pkg.repository === 'string' ? pkg.repository : pkg.repository.url;
+    if (!raw || typeof raw !== 'string')
+        return null;
+    return raw.replace(/^git\+/, '').replace(/\.git$/, '') + (/\.git$/.test(raw) ? '.git' : '');
+}
+/** Silently probe a remote git URL. Returns the default branch on success. */
+function probeRemote(repoUrl) {
+    try {
+        const result = spawnSafe('git', ['ls-remote', '--symref', repoUrl, 'HEAD'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 15000
+        });
+        if (result.status !== 0 || !result.stdout)
+            return null;
+        const match = result.stdout.match(/^ref:\s+refs\/heads\/(\S+)\s+HEAD/m);
+        if (!match)
+            return null;
+        return { defaultBranch: match[1] };
+    }
+    catch {
+        return null;
+    }
+}
+/** Initialize a local git repo by adopting history from an existing remote.
+ *  Preserves the working tree — local files appear as uncommitted changes
+ *  on top of the remote's HEAD. No force-push is required. */
+export async function adoptExistingRemote(cwd, repoUrl, defaultBranch, dryRun) {
+    console.log(`Adopting history from existing remote: ${repoUrl} (branch: ${defaultBranch})`);
+    if (dryRun) {
+        console.log('  [dry-run] Would run: git init');
+        console.log(`  [dry-run] Would run: git remote add origin ${repoUrl}`);
+        console.log('  [dry-run] Would run: git fetch origin');
+        console.log(`  [dry-run] Would set HEAD to origin/${defaultBranch} without touching working tree`);
+        return true;
+    }
+    // git init
+    runCommandOrThrow('git', ['init'], { cwd });
+    // Same dubious-ownership self-heal as initGit
+    const ownerCheck = spawnSafe('git', ['rev-parse', '--git-dir'], {
+        encoding: 'utf-8',
+        stdio: 'pipe',
+        cwd
+    });
+    if (ownerCheck.stderr && ownerCheck.stderr.includes('dubious ownership')) {
+        console.log(colors.yellow('Git "dubious ownership" error — directory owner SID differs from current user.'));
+        console.log(colors.yellow('Adding safe.directory \'*\' to global git config...'));
+        const fix = spawnSafe('git', ['config', '--global', '--add', 'safe.directory', '*'], {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            shell: true
+        });
+        if (fix.status === 0) {
+            console.log(colors.green('  ✓ Fixed git safe.directory'));
+        }
+        else {
+            throw new Error('Failed to fix git safe.directory. Run manually: git config --global --add safe.directory \'*\'');
+        }
+    }
+    // LF line endings (matches initGit / programming.md)
+    runCommandOrThrow('git', ['config', 'core.autocrlf', 'false'], { cwd });
+    runCommandOrThrow('git', ['config', 'core.eol', 'lf'], { cwd });
+    console.log('  ✓ Configured git for LF line endings');
+    // Add origin (set-url if it somehow exists)
+    const addRemote = runCommand('git', ['remote', 'add', 'origin', repoUrl], { cwd, silent: true });
+    if (!addRemote.success) {
+        runCommand('git', ['remote', 'set-url', 'origin', repoUrl], { cwd, silent: true });
+    }
+    // Fetch — this is the slow step
+    console.log('  Fetching from origin...');
+    const fetchRes = await runCommandAsync('git', ['fetch', 'origin'], { cwd, silent: true });
+    if (!fetchRes.success) {
+        const err = (fetchRes.stderr || fetchRes.output || '').trim();
+        console.error(colors.red(`  Failed to fetch from origin: ${err}`));
+        return false;
+    }
+    // Point local branch at origin/<branch>, set HEAD, refresh index — all without
+    // touching the working tree. `git reset` (mixed) updates the index from HEAD
+    // so existing local files show as modifications/additions vs the remote.
+    runCommandOrThrow('git', ['update-ref', `refs/heads/${defaultBranch}`, `origin/${defaultBranch}`], { cwd });
+    runCommandOrThrow('git', ['symbolic-ref', 'HEAD', `refs/heads/${defaultBranch}`], { cwd });
+    runCommandOrThrow('git', ['reset'], { cwd });
+    runCommand('git', ['branch', `--set-upstream-to=origin/${defaultBranch}`, defaultBranch], { cwd, silent: true });
+    console.log(colors.green(`  ✓ Adopted history from ${repoUrl}`));
+    // Show drift summary
+    const statusRes = runCommand('git', ['status', '--porcelain'], { cwd, silent: true });
+    const changes = (statusRes.output || '').split('\n').filter(l => l.trim().length > 0);
+    if (changes.length === 0) {
+        console.log(colors.dim('  Working tree matches remote HEAD.'));
+    }
+    else {
+        console.log(colors.dim(`  ${changes.length} file(s) differ from remote HEAD — npmglobalize will commit them before publishing.`));
+    }
+    return true;
+}
 /** Initialize git repository */
 export async function initGit(cwd, visibility, dryRun, allowTs) {
     const pkg = readPackageJson(cwd);
@@ -3312,7 +3411,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     const { bump = 'patch', noPublish = false, cleanup = false, install = false, link = false, wsl = false, force = false, files = true, dryRun = false, quiet = true, verbose = false, init = false, gitVisibility = 'private', npmVisibility = 'private', message, conform = false, asis = false, updateDeps = false, updateMajor = false, publishDeps = true, // Default to publishing deps for safety
     publishDepsYes = false, // -pd: auto-yes to dep-cascade prompts (private only)
     publicDeps = false, // -public-deps: cascade public visibility to all deps
-    noPrescan = false, forcePublish = false, fix = true, fixTags = false, rebase = false, show = false, local = false, freeze = false, usePaths = true, allowTs } = options;
+    noPrescan = false, forcePublish = false, fix = true, fixTags = false, rebase = false, show = false, local = false, freeze = false, usePaths = true, allowTs, adopt = false } = options;
     // Show tool version only for recursive dep calls (CLI already prints it at startup)
     const toolVersion = getToolVersion();
     if (!options._fromWorkspace && !options._fromCli) {
@@ -3553,33 +3652,116 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     let justInitialized = false;
     if (!gitStatus.isRepo) {
         console.log('No git repository found.');
-        if (dryRun) {
-            console.log('  [dry-run] Would initialize git repository');
+        // Probe for an existing remote we could adopt history from.
+        // The package.json may already point at a GitHub repo from a previous
+        // publish — adopting it preserves remote history (no force-push needed).
+        const pkgForProbe = readPackageJson(cwd);
+        const probeUrl = getPackageRepoUrl(pkgForProbe);
+        let adoptable = null;
+        if (probeUrl) {
+            console.log(colors.dim(`  Probing existing remote: ${probeUrl} ...`));
+            const probed = probeRemote(probeUrl);
+            if (probed) {
+                adoptable = { url: probeUrl, defaultBranch: probed.defaultBranch };
+                console.log(colors.green(`  ✓ Remote reachable (default branch: ${probed.defaultBranch})`));
+            }
+            else {
+                console.log(colors.dim('  Remote not reachable — falling back to fresh init options.'));
+            }
         }
-        else if (!init && !options.autoInit && !publishDepsYes) {
-            const choice = await promptChoice('No git repository found. What would you like to do?\n  1) Initialize git repository (default)\n  a) Initialize ALL (don\'t ask again for remaining deps)\n  2) Use local install only (skip git/publish)\n  3) Abort\nChoice:', ['1', 'a', '2', '3', '']);
-            if (choice === '2') {
-                console.log(colors.dim('Switching to local-only mode...'));
-                writeConfig(cwd, { ...configOptions, local: true }, new Set(['local']));
-                return doLocalInstall(cwd, options);
+        // Strict -adopt: require a reachable remote, never create a fresh repo
+        if (adopt && !adoptable) {
+            console.error(colors.red('ERROR: -adopt requires a reachable git remote in package.json.repository'));
+            if (probeUrl) {
+                console.error(colors.red(`  Configured: ${probeUrl}`));
+                console.error(colors.red('  Probe failed — check the URL, network, or credentials.'));
             }
-            if (choice === '3') {
-                console.log('Aborted. Run with --init to initialize.');
-                return false;
+            else {
+                console.error(colors.red('  No "repository" field found in package.json.'));
             }
-            if (choice === 'a') {
-                options.autoInit = true;
+            console.error(colors.red('  Drop -adopt to fall back to fresh init, or fix the remote URL.'));
+            return false;
+        }
+        if (dryRun) {
+            if (adoptable) {
+                console.log(`  [dry-run] Would adopt history from ${adoptable.url}`);
+            }
+            else {
+                console.log('  [dry-run] Would initialize git repository');
             }
-            // choice is '1', 'a', or '' (default)
-            const success = await initGit(cwd, gitVisibility, dryRun, allowTs);
+        }
+        else if (adopt && adoptable) {
+            // -adopt bypasses the prompt
+            const success = await adoptExistingRemote(cwd, adoptable.url, adoptable.defaultBranch, dryRun);
             if (!success)
                 return false;
             justInitialized = true;
         }
+        else if (!init && !options.autoInit && !publishDepsYes) {
+            let choice;
+            if (adoptable) {
+                choice = await promptChoice('How would you like to set up git?\n'
+                    + '  1) Adopt history from existing remote (recommended)\n'
+                    + '  2) Initialize fresh git repository\n'
+                    + '  a) Adopt ALL (don\'t ask again for remaining deps)\n'
+                    + '  3) Use local install only (skip git/publish)\n'
+                    + '  4) Abort\nChoice:', ['1', '2', 'a', '3', '4', '']);
+                if (choice === '3') {
+                    console.log(colors.dim('Switching to local-only mode...'));
+                    writeConfig(cwd, { ...configOptions, local: true }, new Set(['local']));
+                    return doLocalInstall(cwd, options);
+                }
+                if (choice === '4') {
+                    console.log('Aborted. Run with --init to initialize.');
+                    return false;
+                }
+                if (choice === 'a')
+                    options.autoInit = true;
+                if (choice === '2') {
+                    const success = await initGit(cwd, gitVisibility, dryRun, allowTs);
+                    if (!success)
+                        return false;
+                }
+                else {
+                    // '1', 'a', '' default → adopt
+                    const success = await adoptExistingRemote(cwd, adoptable.url, adoptable.defaultBranch, dryRun);
+                    if (!success)
+                        return false;
+                }
+            }
+            else {
+                choice = await promptChoice('No git repository found. What would you like to do?\n  1) Initialize git repository (default)\n  a) Initialize ALL (don\'t ask again for remaining deps)\n  2) Use local install only (skip git/publish)\n  3) Abort\nChoice:', ['1', 'a', '2', '3', '']);
+                if (choice === '2') {
+                    console.log(colors.dim('Switching to local-only mode...'));
+                    writeConfig(cwd, { ...configOptions, local: true }, new Set(['local']));
+                    return doLocalInstall(cwd, options);
+                }
+                if (choice === '3') {
+                    console.log('Aborted. Run with --init to initialize.');
+                    return false;
+                }
+                if (choice === 'a')
+                    options.autoInit = true;
+                // choice is '1', 'a', or '' (default)
+                const success = await initGit(cwd, gitVisibility, dryRun, allowTs);
+                if (!success)
+                    return false;
+            }
+            justInitialized = true;
+        }
         else {
-            const success = await initGit(cwd, gitVisibility, dryRun, allowTs);
-            if (!success)
-                return false;
+            // Auto path (--init, autoInit, publishDepsYes): prefer adoption if a
+            // reachable remote was found in package.json.
+            if (adoptable) {
+                const success = await adoptExistingRemote(cwd, adoptable.url, adoptable.defaultBranch, dryRun);
+                if (!success)
+                    return false;
+            }
+            else {
+                const success = await initGit(cwd, gitVisibility, dryRun, allowTs);
+                if (!success)
+                    return false;
+            }
             justInitialized = true;
         }
     }
@@ -4239,7 +4421,8 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                             forcePublish, // Propagate so transitive deps get force-published too
                             _fromDep: true, // Suppress nested prescan
                             rebase, // Propagate so behind-remote deps get rebased automatically
-                            autoInit: options.autoInit // Propagate "init all" choice
+                            autoInit: options.autoInit, // Propagate "init all" choice
+                            adopt // Propagate strict adopt-or-abort flag through cascade
                         });
                         if (!depSuccess) {
                             console.error(colors.red(`Failed to publish ${name}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.178",
+  "version": "1.0.179",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@bobfrankston/freezepak": "^0.1.8",
-    "@bobfrankston/importgen": "^0.1.35",
+    "@bobfrankston/importgen": "^0.1.36",
     "@bobfrankston/mailx": "^1.0.466",
     "@bobfrankston/npmglobalize": "^1.0.153",
     "@bobfrankston/themecolors": "^0.1.6",
@@ -64,7 +64,7 @@
   ".transformedSnapshot": {
     "dependencies": {
       "@bobfrankston/freezepak": "^0.1.8",
-      "@bobfrankston/importgen": "^0.1.35",
+      "@bobfrankston/importgen": "^0.1.36",
       "@bobfrankston/mailx": "^1.0.466",
       "@bobfrankston/npmglobalize": "^1.0.153",
       "@bobfrankston/themecolors": "^0.1.6",