@bobfrankston/npmglobalize 1.0.178 → 1.0.180

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,18 @@ 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.
+-no-import-check, -no-imports
+                Skip the undeclared-imports scan. By default, npmglobalize
+                scans .ts/.js source for imports of packages not declared in
+                any dependencies bucket and warns before publishing. The scan
+                catches silent runtime failures (ERR_MODULE_NOT_FOUND on a
+                clean install) where the import was resolving via a global or
+                parent node_modules at dev time but won't on the target host.
 -force          Continue despite git errors
 -dry-run        Preview what would happen
 -quiet          Suppress npm warnings (default)
@@ -625,9 +679,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,14 @@ 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.
+  -no-import-check
+                  Skip the undeclared-imports scan. Default: scan runs and
+                  warns about packages imported in .ts/.js but missing from
+                  any dependencies bucket (catches silent runtime failures).
   -force          Continue despite git errors
   -dry-run        Preview what would happen
   -quiet          Suppress npm warnings (default)
@@ -117,7 +124,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 +230,13 @@ function parseArgs(args) {
             case '-init':
                 options.init = true;
                 break;
+            case '-adopt':
+                options.adopt = true;
+                break;
+            case '-no-import-check':
+            case '-no-imports':
+                options.noImportCheck = true;
+                break;
             case '-git':
                 i++;
                 if (args[i] === 'private' || args[i] === 'public') {

package/lib.d.ts

@@ -115,6 +115,12 @@ 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;
+    /** Skip the undeclared-imports scan. Default false (scan runs). */
+    noImportCheck?: boolean;
     /** Internal: signals this call is from workspace orchestrator */
     /** Skip the upfront dep-graph prescan */
     noPrescan?: boolean;
@@ -256,6 +262,12 @@ export interface PrescanIssue {
     message: string;
     suggestion?: string;
 }
+export interface UndeclaredImport {
+    name: string;
+    file: string;
+    line: number;
+}
+export declare function findUndeclaredImports(cwd: string, pkg: any): UndeclaredImport[];
 /** Walk the full file: dep graph and collect issues up front — missing scopes,
  *  unresolvable paths, missing package.json, unpublished transitives. Lets the
  *  user resolve all problems before starting the publish cascade instead of
@@ -382,6 +394,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

@@ -13,6 +13,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { execSync, spawn, spawnSync } from 'child_process';
+import { builtinModules } from 'module';
 import { readConfig as readUserConfig, writeConfig as writeUserConfig, configDir } from '@bobfrankston/userconfig';
 import { freezeDependencies } from '@bobfrankston/freezepak';
 import { importgen as runImportgen } from '@bobfrankston/importgen';
@@ -1304,6 +1305,130 @@ function printDepTree(baseDir, indent = 0, visited = new Set()) {
         }
     }
 }
+/** Source-import scan: finds package imports in .ts/.js that aren't declared
+ *  in any of the package.json dep buckets. Catches the failure mode where a
+ *  file imports `@scope/thing` but no one ever added it to dependencies — the
+ *  tarball publishes "fine" and crashes with ERR_MODULE_NOT_FOUND on install.
+ *  The previously-working case usually relies on a global/parent copy that
+ *  Node ESM resolution happened to find. */
+const SOURCE_SKIP_DIRS = new Set([
+    'node_modules', 'prev', '.git', 'dist', 'build', 'out',
+    'coverage', '.next', '.nuxt', '.turbo', '.cache'
+]);
+function collectSourceFiles(dir, acc = [], depth = 0) {
+    if (depth > 12)
+        return acc;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return acc;
+    }
+    for (const ent of entries) {
+        const name = ent.name;
+        if (ent.isDirectory()) {
+            if (SOURCE_SKIP_DIRS.has(name))
+                continue;
+            if (name.startsWith('.'))
+                continue; // .git, .vscode, .idea, etc.
+            collectSourceFiles(path.join(dir, name), acc, depth + 1);
+        }
+        else if (ent.isFile()) {
+            if (name.endsWith('.d.ts') || name.endsWith('.map'))
+                continue;
+            if (name.endsWith('.ts') || name.endsWith('.tsx')
+                || name.endsWith('.js') || name.endsWith('.jsx')
+                || name.endsWith('.mjs') || name.endsWith('.cjs')) {
+                acc.push(path.join(dir, name));
+            }
+        }
+    }
+    return acc;
+}
+/** Extract the package name from an ESM/CJS module specifier.
+ *  Returns null for relative paths, absolute paths, URLs, node: builtins. */
+function specifierToPackageName(spec) {
+    if (!spec)
+        return null;
+    if (spec.startsWith('.'))
+        return null; // ./ or ../
+    if (spec.startsWith('/'))
+        return null; // /abs
+    if (spec.startsWith('node:'))
+        return null; // node:fs
+    if (/^[a-z][a-z0-9+.-]*:/i.test(spec))
+        return null; // url/data
+    if (spec.startsWith('#'))
+        return null; // subpath import
+    if (spec.startsWith('@')) {
+        const parts = spec.split('/');
+        return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+    }
+    return spec.split('/')[0];
+}
+const NODE_BUILTIN_NAMES = new Set(builtinModules);
+export function findUndeclaredImports(cwd, pkg) {
+    const declared = new Set();
+    for (const k of DEP_KEYS) {
+        const bucket = pkg[k] || pkg['.' + k]; // also consult the backup bucket if a transform is pending
+        if (bucket)
+            for (const n of Object.keys(bucket))
+                declared.add(n);
+    }
+    const selfName = pkg.name;
+    // One specifier per line is the common case; a few patterns cover the rest.
+    // We process line-by-line so we can report file:line and avoid pathological
+    // backtracking on huge files.
+    const FROM_RE = /\bfrom\s+['"]([^'"]+)['"]/g;
+    const BARE_IMPORT_RE = /(?:^|;|\s)import\s+['"]([^'"]+)['"]/g;
+    const DYNAMIC_RE = /(?:^|[^.\w$])import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    const REQUIRE_RE = /(?:^|[^.\w$])require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    const PATTERNS = [FROM_RE, BARE_IMPORT_RE, DYNAMIC_RE, REQUIRE_RE];
+    const findings = new Map();
+    const files = collectSourceFiles(cwd);
+    for (const f of files) {
+        let content;
+        try {
+            content = fs.readFileSync(f, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        // Quick reject: no import/require keyword anywhere → skip
+        if (!/\bimport\b|\brequire\s*\(/.test(content))
+            continue;
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            for (const re of PATTERNS) {
+                re.lastIndex = 0;
+                let m;
+                while ((m = re.exec(line))) {
+                    const spec = m[1];
+                    const pkgName = specifierToPackageName(spec);
+                    if (!pkgName)
+                        continue;
+                    if (NODE_BUILTIN_NAMES.has(pkgName))
+                        continue;
+                    if (pkgName === selfName)
+                        continue;
+                    if (declared.has(pkgName))
+                        continue;
+                    if (!findings.has(pkgName)) {
+                        findings.set(pkgName, {
+                            file: path.relative(cwd, f).replace(/\\/g, '/'),
+                            line: i + 1
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return [...findings.entries()]
+        .map(([name, loc]) => ({ name, ...loc }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
 /** Walk the full file: dep graph and collect issues up front — missing scopes,
  *  unresolvable paths, missing package.json, unpublished transitives. Lets the
  *  user resolve all problems before starting the publish cascade instead of
@@ -3045,6 +3170,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 +3536,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, noImportCheck = false } = options;
     // Show tool version only for recursive dep calls (CLI already prints it at startup)
     const toolVersion = getToolVersion();
     if (!options._fromWorkspace && !options._fromCli) {
@@ -3455,6 +3679,41 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
             console.log(colors.dim('Prescan: no issues found in dep graph.'));
         }
     }
+    // Source-import scan — catches imports of packages not declared in
+    // dependencies/devDependencies/peer/optional. Runs by default; skip with
+    // -no-import-check. Only at the top level (deps in the cascade will be
+    // scanned when their own globalize() runs).
+    if (!noImportCheck && !cleanup && !options._fromDep && !options._fromWorkspace) {
+        const scanPkg = readPackageJson(cwd);
+        const undeclared = findUndeclaredImports(cwd, scanPkg);
+        if (undeclared.length > 0) {
+            console.log('');
+            console.log(colors.yellow(`Undeclared imports found (${undeclared.length}):`));
+            for (const u of undeclared) {
+                console.log(colors.yellow(`  ${u.name}`)
+                    + colors.dim(`  (${u.file}:${u.line})`));
+            }
+            console.log(colors.dim('  These packages are imported but not in any package.json dep bucket.'));
+            console.log(colors.dim('  After publish, `npm install` won\'t pull them and the package will'));
+            console.log(colors.dim('  crash with ERR_MODULE_NOT_FOUND on a clean install.'));
+            const interactive = !init && !options.autoInit && !publishDepsYes && !dryRun;
+            if (interactive) {
+                const ok = await confirm('Continue anyway?', false);
+                if (!ok) {
+                    console.log('Aborted. Add the missing packages to dependencies and re-run.');
+                    console.log(colors.dim('  Tip: for siblings, use "file:../<dir>"; otherwise add the latest published version.'));
+                    return false;
+                }
+            }
+            else {
+                console.log(colors.yellow('  (non-interactive mode — continuing, but the install will likely fail at runtime)'));
+            }
+            console.log('');
+        }
+        else if (verbose) {
+            console.log(colors.dim('Import scan: all imports are declared.'));
+        }
+    }
     // Check ignore files first (unless cleanup mode)
     if (!cleanup && !asis) {
         const checkResult = checkIgnoreFiles(cwd, { conform, asis, verbose, allowTs });
@@ -3553,33 +3812,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 +4581,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.180",
   "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",