@bobfrankston/npmglobalize 1.0.185 → 1.0.187

package/README.md

@@ -585,6 +585,18 @@ Cycle-safe via a shared visited set; each project is built at most once per run.
 
 This complements the existing publish cascade (which ensures version refs are correct) by closing the build-freshness gap that `npm install` alone left open.
 
+#### TypeScript 6 `types` auto-fix
+
+TypeScript 6 dropped the legacy behavior of auto-including every installed `@types/*` package. A `tsconfig.json` with no explicit `compilerOptions.types` then loses the Node globals (`process`, `Buffer`, …) and the build fails with `TS2591`.
+
+Before each build, when the global `tsc` is version 6 or newer, `npmglobalize` patches the project's `tsconfig.json` to add an explicit `types` list — enumerating the installed `@types/*` packages (e.g. `"types": ["node", …]`) — restoring the old behavior. The edit is:
+
+- **Conservative** — only applied when `compilerOptions.types` is **absent**, `node_modules/@types/node` is actually installed, and there is no `extends` (whose merged `types` can't be seen). An explicit `types` you already set is never overridden.
+- **Format-preserving** — the single `types` key is inserted into the existing `compilerOptions` block; comments, ordering, and indentation are left intact.
+- **Idempotent** — once the list is present, subsequent runs skip it.
+
+If the patch can't be applied for some reason and the build still fails with `TS2591`, the failure summary prints a hint to add `"types": ["node"]` manually.
+
 ### The `.dependencies` Backup (Internal/Transient)
 
 **You should never see `.dependencies` in your `package.json` under normal operation.** It is a temporary internal backup that exists only during the brief publish cycle and is removed automatically when the cycle completes.

package/lib.d.ts

@@ -296,6 +296,7 @@ export declare function parseVersionTag(tag: string): number[] | null;
 export declare function compareVersions(a: number[], b: number[]): number;
 /** Fix version/tag mismatches */
 export declare function fixVersionTagMismatch(cwd: string, pkg: any, verbose?: boolean): boolean;
+export declare function printPnpmSuggestionSummary(): void;
 /** Return declared deps (dependencies + devDependencies) that don't resolve from
  *  `pkgDir`. Skips `workspace:`/`link:` specs (handled by workspace tooling /
  *  rarely used). `file:` deps are checked: npm installs them as junctions

package/lib.js

@@ -29,6 +29,7 @@ function spawnSafe(cmd, args, options = {}) {
     return spawnSync(cmd, args, opts);
 }
 import readline from 'readline';
+import { styleText } from 'util';
 import libversion from 'libnpmversion';
 import JSON5 from 'json5';
 import { fileURLToPath } from 'url';
@@ -1666,6 +1667,59 @@ export function fixVersionTagMismatch(cwd, pkg, verbose = false) {
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
+/** User-requested pnpm-eval hook (2026-05-14). The first local `npm install`
+ *  failure in a process prints a yellow-on-red banner and pauses 60s so the
+ *  user can read it. Every failure (first and subsequent) is captured in
+ *  `_pnpmFailureContexts` so `printPnpmSuggestionSummary()` can re-emit the
+ *  banner — listing all failure sites — at end-of-run, in case the live
+ *  banner scrolled past. Remove once pnpm-vs-npm decision is made. */
+let _pnpmSuggestionShown = false;
+const _pnpmFailureContexts = [];
+function _pnpmBanner(contexts) {
+    const width = 76;
+    const wrap = (s) => styleText(['yellow', 'bgRed', 'bold'], ' ' + s.padEnd(width - 2) + ' ');
+    const body = [
+        '',
+        contexts.length > 1
+            ? `npm install FAILED  --  ${contexts.length} sites  --  consider trying pnpm`
+            : 'npm install FAILED  --  consider trying pnpm',
+        '',
+    ];
+    for (const c of contexts) {
+        const label = `  - ${c}`;
+        body.push(label.length > width - 2 ? label.slice(0, width - 5) + '...' : label);
+    }
+    body.push('', 'pnpm uses a content-addressed store with strict node_modules and', 'much faster installs. Commands mirror npm; great workspace support.', '', 'Try:   npm i -g pnpm  &&  pnpm import  &&  pnpm install', '');
+    return body.map(wrap);
+}
+async function suggestPnpmOnInstallFailure(context) {
+    _pnpmFailureContexts.push(context);
+    if (_pnpmSuggestionShown)
+        return;
+    _pnpmSuggestionShown = true;
+    const lines = _pnpmBanner([context]);
+    console.error('');
+    for (const l of lines)
+        console.error(l);
+    console.error(styleText(['yellow', 'bgRed', 'bold'], ' ' + 'Pausing 60s so you can read this. Ctrl+C to abort.'.padEnd(74) + ' '));
+    console.error('');
+    await new Promise(resolve => setTimeout(resolve, 60_000));
+}
+/** Re-emit the pnpm banner at end-of-run if any `npm install` failed.
+ *  No-op when nothing failed. Safe to call from multiple summary paths —
+ *  guarded so the summary banner prints at most once per process. */
+let _pnpmSummaryPrinted = false;
+export function printPnpmSuggestionSummary() {
+    if (_pnpmSummaryPrinted)
+        return;
+    if (_pnpmFailureContexts.length === 0)
+        return;
+    _pnpmSummaryPrinted = true;
+    console.error('');
+    for (const l of _pnpmBanner(_pnpmFailureContexts))
+        console.error(l);
+    console.error('');
+}
 /** Wait for a package version to appear on the npm registry.
  *  First-time publishes (brand-new package name) take much longer to
  *  propagate than version bumps — npm has no cached metadata to update,
@@ -1828,6 +1882,7 @@ export async function ensureFileDepModules(cwd, verbose = false, visited = new S
             console.error(colors.red(`  ✗ npm install failed in ${abs}`));
             if (r.stderr)
                 console.error(colors.dim(r.stderr.split('\n').slice(0, 5).join('\n')));
+            await suggestPnpmOnInstallFailure(`ensureFileDepModules (cwd): ${abs}`);
         }
     }
     for (const key of ['dependencies', 'devDependencies']) {
@@ -1865,12 +1920,127 @@ export async function ensureFileDepModules(cwd, verbose = false, visited = new S
                     console.error(colors.red(`  ✗ npm install failed in ${target}`));
                     if (r.stderr)
                         console.error(colors.dim(r.stderr.split('\n').slice(0, 5).join('\n')));
+                    await suggestPnpmOnInstallFailure(`ensureFileDepModules (file: dep ${name}): ${target}`);
                 }
             }
             await ensureFileDepModules(target, verbose, visited);
         }
     }
 }
+/** Cached major version of the global `tsc`. null = not yet probed,
+ *  0 = probe failed / tsc not found. TypeScript 6 stopped auto-including
+ *  every `@types/*` package, so a tsconfig that relied on that needs an
+ *  explicit `types` list under TS6+. */
+let _tscMajor = null;
+/** Major version of the globally-installed `tsc`, or 0 if undeterminable.
+ *  Cached for the run. Needs shell:true on Windows to resolve `tsc.cmd`. */
+function getTscMajor() {
+    if (_tscMajor !== null)
+        return _tscMajor;
+    _tscMajor = 0;
+    try {
+        const result = spawnSafe('tsc', ['--version'], { stdio: 'pipe', shell: true, env: process.env });
+        const m = (result.stdout || '').match(/Version\s+(\d+)\./);
+        if (m)
+            _tscMajor = parseInt(m[1], 10);
+    }
+    catch { /* leave at 0 — can't probe, assume pre-6 (no patch) */ }
+    return _tscMajor;
+}
+/** Insert a `"types": [...]` line as the first property of `compilerOptions`,
+ *  preserving the file's existing formatting/comments. Returns the patched text,
+ *  or null if the object couldn't be located safely (caller leaves file alone).
+ *  Only ever called when `compilerOptions.types` is absent. */
+function insertTypesIntoTsconfig(text, typesArr) {
+    const arrLiteral = '[' + typesArr.map(t => JSON.stringify(t)).join(', ') + ']';
+    const m = text.match(/"compilerOptions"\s*:\s*\{/);
+    if (!m)
+        return null;
+    const braceEnd = m.index + m[0].length;
+    const rest = text.slice(braceEnd);
+    const ws = rest.match(/^\s*/)[0];
+    // Empty object: `compilerOptions: {}` (or whitespace only before `}`)
+    if (rest.slice(ws.length).startsWith('}')) {
+        // Indent one level deeper than the `compilerOptions` line itself.
+        const lineStart = text.lastIndexOf('\n', m.index) + 1;
+        const baseIndent = text.slice(lineStart, m.index).match(/^\s*/)[0];
+        const propIndent = baseIndent + '  ';
+        return text.slice(0, braceEnd) + '\n' + propIndent + `"types": ${arrLiteral}\n` + baseIndent + text.slice(braceEnd + ws.length);
+    }
+    // Multiline object: derive property indent from the existing first property.
+    if (ws.includes('\n')) {
+        const propIndent = ws.slice(ws.lastIndexOf('\n') + 1);
+        return text.slice(0, braceEnd) + '\n' + propIndent + `"types": ${arrLiteral},` + text.slice(braceEnd);
+    }
+    // Inline single-line object: `{ "target": ... }`
+    return text.slice(0, braceEnd) + ` "types": ${arrLiteral},` + text.slice(braceEnd);
+}
+/** TypeScript 6 dropped the legacy behavior of auto-including every installed
+ *  `@types/*` package. A tsconfig with no explicit `compilerOptions.types` then
+ *  loses the Node globals (`process`, `Buffer`, ...), breaking the build with
+ *  `TS2591`. When building under TS6+, add an explicit `types` list enumerating
+ *  the installed `@types/*` (restoring the old behavior). Idempotent and
+ *  conservative — only patches when `types` is absent, `@types/node` is actually
+ *  installed, and there is no `extends` (whose merged `types` we can't see). */
+function ensureTsconfigNodeTypes(cwd) {
+    if (getTscMajor() < 6)
+        return;
+    const tsconfigPath = path.join(cwd, 'tsconfig.json');
+    let text;
+    try {
+        text = fs.readFileSync(tsconfigPath, 'utf-8');
+    }
+    catch {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON5.parse(text);
+    }
+    catch {
+        return;
+    }
+    const co = parsed?.compilerOptions;
+    if (!co || typeof co !== 'object')
+        return;
+    // Respect any explicit choice; never override a user-set `types`.
+    if (co.types !== undefined)
+        return;
+    // `extends` may already supply `types`; a local array would override it, so leave it.
+    if (parsed.extends !== undefined)
+        return;
+    // Gate on @types/node actually being installed so the list resolves and we
+    // only touch genuine Node projects.
+    const typesDir = path.join(cwd, 'node_modules', '@types');
+    if (!fs.existsSync(path.join(typesDir, 'node')))
+        return;
+    let installed;
+    try {
+        installed = fs.readdirSync(typesDir, { withFileTypes: true })
+            .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+            .map(e => e.name);
+    }
+    catch {
+        return;
+    }
+    if (!installed.length)
+        return;
+    // node first, rest sorted, for a stable readable list.
+    installed.sort();
+    const typesArr = ['node', ...installed.filter(n => n !== 'node')];
+    const patched = insertTypesIntoTsconfig(text, typesArr);
+    if (!patched) {
+        recordBuildIssue(parsed.name || path.basename(cwd), 'warning', `TS6+ build may fail: couldn't locate compilerOptions in ${tsconfigPath} to add explicit "types"`);
+        return;
+    }
+    try {
+        fs.writeFileSync(tsconfigPath, patched);
+        console.log(colors.cyan(`  Patched tsconfig.json: added "types": [${typesArr.join(', ')}] (TypeScript ${_tscMajor}+ no longer auto-includes @types/*)`));
+    }
+    catch (error) {
+        console.error(colors.yellow(`  Could not write tsconfig.json patch: ${error.message}`));
+    }
+}
 /** Build a single project: detect tsconfig, prompt to add `build: tsc` if a
  *  TypeScript project lacks a build script, run `npm run build`, record
  *  failures. Returns true if build succeeded (or was skipped because no
@@ -1903,6 +2073,7 @@ export async function buildProject(cwd, opts = {}) {
             return true;
         }
     }
+    ensureTsconfigNodeTypes(cwd);
     console.log(`Building ${pkg.name || cwd}...`);
     const buildResult = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
     if (buildResult.success) {
@@ -1993,6 +2164,7 @@ export async function ensureWorkspaceDepModules(rootDir, members, verbose = fals
         console.error(colors.red(`  ✗ npm install failed in ${root}`));
         if (r.stderr)
             console.error(colors.dim(r.stderr.split('\n').slice(0, 5).join('\n')));
+        await suggestPnpmOnInstallFailure(`ensureWorkspaceDepModules: ${root}`);
     }
 }
 /** Run npm install -g with retries for registry propagation delay.
@@ -2256,6 +2428,13 @@ function diagnoseBuildFailure(errorText, cwd) {
         console.error(colors.yellow('  Check file ownership and that no other process has files locked.'));
         diagnosed = true;
     }
+    // Pattern: TS6 dropped @types/* auto-inclusion → Node globals missing.
+    // (Safety net for when the proactive ensureTsconfigNodeTypes patch didn't fire.)
+    if (!diagnosed && /error TS2591|Do you need to install type definitions for node/.test(errorText)) {
+        console.error(colors.yellow('\n  Hint: TypeScript 6 no longer auto-includes @types/*, so Node globals (process, Buffer) are unresolved.'));
+        console.error(colors.yellow(`  Fix: add  "types": ["node"]  to compilerOptions in ${path.join(cwd, 'tsconfig.json')}`));
+        diagnosed = true;
+    }
     // Pattern: TypeScript compilation error
     if (!diagnosed && /error TS\d+/.test(errorText)) {
         console.error(colors.yellow('\n  Hint: TypeScript compilation errors. Fix the type errors above before publishing.'));
@@ -4111,6 +4290,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
             // workspaces[] array order; rewrite to topological order so deps build
             // before consumers (avoids stale-.d.ts errors in cross-package imports).
             const restoreWorkspaces = reorderWorkspacesForBuild(cwd, pkg, verbose);
+            ensureTsconfigNodeTypes(cwd);
             try {
                 // Always capture output so we can extract tsc errors for the summary
                 const buildResult = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
@@ -4788,6 +4968,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
             console.log(`  ${colors.yellow('!')} ${s}`);
         console.log(colors.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
         console.log('');
+        printPnpmSuggestionSummary();
         return true;
     }
     // Skip if private
@@ -5901,6 +6082,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     }
     console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
     console.log('');
+    printPnpmSuggestionSummary();
     // Only show "To use run" message if package provides commands (has bin field)
     if (finalPkg.bin) {
         const commandName = finalPkg.name.includes('/') ? finalPkg.name.split('/')[1] : finalPkg.name;
@@ -6254,6 +6436,7 @@ export async function globalizeWorkspace(rootDir, options = {}, configOptions =
     }
     console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
     console.log('');
+    printPnpmSuggestionSummary();
     // Global install of the workspace root (monorepo CLI)
     const { install = false, link = false, wsl = false, dryRun = false, verbose = false } = options;
     const rootPkgFinal = readPackageJson(rootDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.185",
+  "version": "1.0.187",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "@bobfrankston/freezepak": "^0.1.8",
-    "@bobfrankston/importgen": "^0.1.36",
-    "@bobfrankston/themecolors": "^0.1.6",
+    "@bobfrankston/importgen": "^0.1.37",
+    "@bobfrankston/themecolors": "^0.1.7",
     "@bobfrankston/userconfig": "^1.0.9",
     "@npmcli/package-json": "^7.0.4",
     "json5": "^2.2.3",
@@ -60,8 +60,8 @@
   ".transformedSnapshot": {
     "dependencies": {
       "@bobfrankston/freezepak": "^0.1.8",
-      "@bobfrankston/importgen": "^0.1.36",
-      "@bobfrankston/themecolors": "^0.1.6",
+      "@bobfrankston/importgen": "^0.1.37",
+      "@bobfrankston/themecolors": "^0.1.7",
       "@bobfrankston/userconfig": "^1.0.9",
       "@npmcli/package-json": "^7.0.4",
       "json5": "^2.2.3",