@bobfrankston/npmglobalize 1.0.142 → 1.0.144

package/cli.js

@@ -2,7 +2,7 @@
 /**
  * npmglobalize CLI - Transform file: dependencies to npm versions for publishing
  */
-import { globalize, globalizeWorkspace, readConfig, readPackageJson, readUserNpmConfig, writeConfig, writePackageJson, confirm, getBuildIssues, clearBuildIssues } from './lib.js';
+import { globalize, globalizeWorkspace, installCleanupHandlers, readConfig, readPackageJson, readUserNpmConfig, writeConfig, writePackageJson, confirm, getBuildIssues, clearBuildIssues, recordBuildIssue, extractFirstTscError } from './lib.js';
 import fs from 'fs';
 import path from 'path';
 import { styleText } from 'util';
@@ -343,6 +343,7 @@ function printBuildSummary() {
     console.log('');
 }
 export async function main() {
+    installCleanupHandlers();
     // Show version at the very start
     const ownPkgPath = path.join(__dirname, 'package.json');
     const ownPkg = JSON.parse(fs.readFileSync(ownPkgPath, 'utf-8'));
@@ -402,15 +403,23 @@ export async function main() {
                 }
             }
             if (pkg.scripts?.build) {
-                const { execSync } = await import('child_process');
-                try {
-                    console.log(`Building ${cwd}...`);
-                    execSync('npm run build', { cwd, stdio: 'inherit' });
+                const { spawnSync } = await import('child_process');
+                console.log(`Building ${cwd}...`);
+                const buildResult = spawnSync('npm', ['run', 'build'], {
+                    cwd, encoding: 'utf-8', stdio: 'pipe', shell: true
+                });
+                if (buildResult.status === 0) {
                     console.log(styleText('green', '✓ Build succeeded'));
                 }
-                catch (error) {
+                else {
+                    const buildOutput = (buildResult.stderr || '') + (buildResult.stdout || '');
+                    if (buildOutput)
+                        console.error(buildOutput);
                     console.error(styleText('red', `Build failed in ${cwd}`));
+                    const firstErr = extractFirstTscError(buildOutput);
+                    recordBuildIssue(pkg.name || path.basename(cwd), 'error', firstErr || 'Build failed');
                     if (!cliOptions.force) {
+                        printBuildSummary();
                         process.exit(1);
                     }
                     console.log(styleText('yellow', 'Continuing with --force...'));

package/ignorepatterns.json5

@@ -15,7 +15,8 @@
             "*.pfx",
             "token",
             "tokens",
-            "*.token"
+            "*.token",
+            "*.tgz"
         ],
         // Prompted or auto-added with --conform
         recommended: [

package/lib.d.ts

@@ -22,6 +22,9 @@ export declare function recordBuildIssue(module: string, severity: 'error' | 'wa
 export declare function getBuildIssues(): readonly BuildIssue[];
 /** Clear accumulated issues (call at start of run) */
 export declare function clearBuildIssues(): void;
+/** Extract the first TypeScript error line from build output for the summary.
+ *  Returns a short string like "file.ts(42,5): error TS2339: Property 'foo' ..." */
+export declare function extractFirstTscError(output: string): string | null;
 /** Options for the globalize operation */
 export interface GlobalizeOptions {
     /** Bump type: patch (default), minor, major */
@@ -129,6 +132,8 @@ export declare function readConfig(dir: string): Partial<GlobalizeOptions>;
 export declare function writeConfig(dir: string, config: Partial<GlobalizeOptions>, explicitKeys?: Set<string>): void;
 /** Write package.json to a directory */
 export declare function writePackageJson(dir: string, pkg: any): void;
+/** Install signal/exit handlers that restore `.dependencies` backups on abnormal exit. */
+export declare function installCleanupHandlers(): void;
 /** Resolve a file: path to absolute path */
 export declare function resolveFilePath(fileRef: string, baseDir: string): string;
 /** Check if a dependency value is a file: reference */
@@ -185,7 +190,8 @@ export declare function transformDeps(pkg: any, baseDir: string, verbose?: boole
         path: string;
     }>;
 };
-/** Restore file: dependencies from .dependencies */
+/** Restore file: dependencies from .dependencies using a three-way merge that
+ *  preserves any external modifications made since the last transform. */
 export declare function restoreDeps(pkg: any, verbose?: boolean): boolean;
 /** Check if .dependencies exist (already transformed) */
 export declare function hasBackup(pkg: any): boolean;
@@ -265,6 +271,7 @@ declare const _default: {
     validatePackageJson: typeof validatePackageJson;
     confirm: typeof confirm;
     initGit: typeof initGit;
+    installCleanupHandlers: typeof installCleanupHandlers;
 };
 export default _default;
 //# sourceMappingURL=lib.d.ts.map

package/lib.js

@@ -46,6 +46,25 @@ export function getBuildIssues() {
 export function clearBuildIssues() {
     _buildIssues.length = 0;
 }
+/** Extract the first TypeScript error line from build output for the summary.
+ *  Returns a short string like "file.ts(42,5): error TS2339: Property 'foo' ..." */
+export function extractFirstTscError(output) {
+    if (!output)
+        return null;
+    // tsc errors: src/file.ts(line,col): error TS1234: message
+    const tscMatch = output.match(/^(.+?\(\d+,\d+\): error TS\d+: .+)$/m);
+    if (tscMatch) {
+        const line = tscMatch[1];
+        return line.length > 120 ? line.slice(0, 117) + '...' : line;
+    }
+    // Generic "error" line
+    const errMatch = output.match(/^(error .+)$/m);
+    if (errMatch) {
+        const line = errMatch[1];
+        return line.length > 120 ? line.slice(0, 117) + '...' : line;
+    }
+    return null;
+}
 /**
  * Remove 'nul' files from a directory tree (Windows reserved name issue).
  * These files break git and npm on Windows. Uses \\?\ prefix to bypass name validation.
@@ -294,10 +313,111 @@ export function writeConfig(dir, config, explicitKeys) {
     lines.push('}');
     fs.writeFileSync(configPath, lines.join('\n') + '\n');
 }
+/** Package.json paths with a live `.dependencies` backup on disk.
+ *  Tracked so the exit handler can restore them if the process dies mid-run. */
+const dirtyPackageJsons = new Set();
 /** Write package.json to a directory */
 export function writePackageJson(dir, pkg) {
     const pkgPath = path.join(dir, 'package.json');
     fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    if (hasBackup(pkg)) {
+        dirtyPackageJsons.add(pkgPath);
+    }
+    else {
+        dirtyPackageJsons.delete(pkgPath);
+    }
+}
+/** Three-way merge that restores `.dependencies` backup into `dependencies` while
+ *  preserving external modifications made since the last transform.
+ *
+ *  Uses `.transformedSnapshot` (written by transformDeps) to distinguish
+ *  "untouched transform output" from "externally modified":
+ *    - current[name] === snapshot[name] → untouched, restore to backup value
+ *    - current[name] !== snapshot[name] → modified externally, keep current
+ *    - name in backup but missing from current → removed externally, leave removed
+ *    - name in current but not in backup → added externally, keep
+ *
+ *  If no snapshot exists (legacy backup from before this mechanism), falls back to
+ *  blind restore plus new-dep merge, matching the old behavior. */
+function mergeRestore(pkg, verbose = false) {
+    const snapshot = pkg['.transformedSnapshot'];
+    let restored = false;
+    for (const key of DEP_KEYS) {
+        const dotKey = '.' + key;
+        if (!pkg[dotKey])
+            continue;
+        const backup = pkg[dotKey];
+        const current = pkg[key] || {};
+        const snap = snapshot?.[key];
+        const merged = { ...current };
+        for (const [name, backupValue] of Object.entries(backup)) {
+            if (!(name in current))
+                continue; // removed externally — leave removed
+            if (snap && name in snap) {
+                if (current[name] === snap[name]) {
+                    merged[name] = backupValue; // untouched — restore
+                }
+                else if (verbose) {
+                    console.log(colors.yellow(`  Preserving externally-modified ${key}.${name}: ${current[name]} (transform wrote ${snap[name]})`));
+                }
+            }
+            else {
+                merged[name] = backupValue; // legacy: no snapshot, blind restore
+            }
+        }
+        pkg[key] = merged;
+        delete pkg[dotKey];
+        restored = true;
+    }
+    if (restored && snapshot) {
+        delete pkg['.transformedSnapshot'];
+    }
+    return restored;
+}
+/** Synchronous emergency restore — called from signal/exit handlers.
+ *  Reads each tracked package.json, runs the three-way merge, writes it back. */
+function emergencyRestoreDeps() {
+    if (dirtyPackageJsons.size === 0)
+        return;
+    console.error(colors.yellow(`\nRestoring file: dependencies in ${dirtyPackageJsons.size} package.json file(s)...`));
+    for (const pkgPath of dirtyPackageJsons) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            if (mergeRestore(pkg)) {
+                fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+                console.error(colors.green(`  ✓ ${pkgPath}`));
+            }
+        }
+        catch (err) {
+            console.error(colors.red(`  ✗ ${pkgPath}: ${err.message}`));
+        }
+    }
+    dirtyPackageJsons.clear();
+}
+let cleanupHandlersInstalled = false;
+/** Install signal/exit handlers that restore `.dependencies` backups on abnormal exit. */
+export function installCleanupHandlers() {
+    if (cleanupHandlersInstalled)
+        return;
+    cleanupHandlersInstalled = true;
+    process.on('exit', emergencyRestoreDeps);
+    const signalHandler = (signal) => {
+        emergencyRestoreDeps();
+        process.exit(128 + (signal === 'SIGINT' ? 2 : signal === 'SIGTERM' ? 15 : 1));
+    };
+    process.on('SIGINT', signalHandler);
+    process.on('SIGTERM', signalHandler);
+    process.on('SIGHUP', signalHandler);
+    process.on('uncaughtException', (err) => {
+        console.error(colors.red('\nUncaught exception:'), err);
+        emergencyRestoreDeps();
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason) => {
+        console.error(colors.red('\nUnhandled rejection:'), reason);
+        emergencyRestoreDeps();
+        process.exit(1);
+    });
 }
 /** Resolve a file: path to absolute path */
 export function resolveFilePath(fileRef, baseDir) {
@@ -747,36 +867,21 @@ function hasLocalChanges(packageName, version, targetPath, verbose) {
 export function transformDeps(pkg, baseDir, verbose = false, forcePublish = false) {
     let transformed = false;
     const unpublished = [];
+    // If re-running on a previously-transformed pkg, merge-restore first.
+    // This preserves any external modifications (AI tools, npm install, manual edits)
+    // made since the last transform, then proceeds to re-transform from a clean slate.
+    if (hasBackup(pkg)) {
+        mergeRestore(pkg, verbose);
+    }
     for (const key of DEP_KEYS) {
         if (!pkg[key])
             continue;
         const dotKey = '.' + key;
-        // If .dependencies already exists, restore it and merge any new dependencies
-        if (pkg[dotKey]) {
-            // Save any new dependencies that aren't in .dependencies
-            const currentDeps = { ...pkg[key] };
-            // Restore .dependencies back to dependencies
-            pkg[key] = { ...pkg[dotKey] };
-            // Merge in any NEW dependencies that were added since transformation
-            for (const [name, value] of Object.entries(currentDeps)) {
-                if (!(name in pkg[dotKey])) {
-                    // This is a new dependency, add it
-                    pkg[key][name] = value;
-                    // Also add to .dependencies backup
-                    pkg[dotKey][name] = value;
-                    if (verbose) {
-                        console.log(`  Merged new dependency: ${name}`);
-                    }
-                }
-            }
-        }
         const hasFileRefs = Object.values(pkg[key]).some(v => isFileRef(v));
         if (!hasFileRefs)
             continue;
-        // Backup original (or update existing backup with merged deps)
-        if (!pkg[dotKey]) {
-            pkg[dotKey] = { ...pkg[key] };
-        }
+        // Backup original
+        pkg[dotKey] = { ...pkg[key] };
         // Transform file: refs to npm versions
         for (const [name, value] of Object.entries(pkg[key])) {
             if (isFileRef(value)) {
@@ -827,6 +932,17 @@ export function transformDeps(pkg, baseDir, verbose = false, forcePublish = fals
             }
         }
     }
+    // Record snapshot of transform output so restore can distinguish untouched
+    // entries from those modified externally since the transform ran.
+    if (transformed) {
+        const snapshot = {};
+        for (const key of DEP_KEYS) {
+            if (pkg['.' + key]) {
+                snapshot[key] = { ...pkg[key] };
+            }
+        }
+        pkg['.transformedSnapshot'] = snapshot;
+    }
     return { transformed, unpublished };
 }
 /** Build and print a dependency tree of file: references.
@@ -870,21 +986,10 @@ function printDepTree(baseDir, indent = 0, visited = new Set()) {
         }
     }
 }
-/** Restore file: dependencies from .dependencies */
+/** Restore file: dependencies from .dependencies using a three-way merge that
+ *  preserves any external modifications made since the last transform. */
 export function restoreDeps(pkg, verbose = false) {
-    let restored = false;
-    for (const key of DEP_KEYS) {
-        const dotKey = '.' + key;
-        if (pkg[dotKey]) {
-            pkg[key] = pkg[dotKey];
-            delete pkg[dotKey];
-            restored = true;
-            if (verbose) {
-                console.log(`  Restored ${key} from ${dotKey}`);
-            }
-        }
-    }
-    return restored;
+    return mergeRestore(pkg, verbose);
 }
 /** Check if .dependencies exist (already transformed) */
 export function hasBackup(pkg) {
@@ -2746,17 +2851,24 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     if (pkg.scripts?.build && !options._fromCli) {
         console.log(`${timestamp()} Running build...`);
         if (!dryRun) {
-            const buildResult = runCommand('npm', ['run', 'build'], { cwd, silent: !verbose });
+            // Always capture output so we can extract tsc errors for the summary
+            const buildResult = runCommand('npm', ['run', 'build'], { cwd, silent: true });
             if (!buildResult.success) {
-                console.error(colors.red('ERROR: Build failed:'), buildResult.stderr || buildResult.output);
-                diagnoseBuildFailure(buildResult.stderr || buildResult.output || '', cwd);
-                recordBuildIssue(pkg.name || path.basename(cwd), 'error', 'Build failed');
+                const buildOutput = buildResult.stderr || buildResult.output;
+                if (buildOutput)
+                    console.error(buildOutput);
+                console.error(colors.red('ERROR: Build failed'));
+                diagnoseBuildFailure(buildOutput || '', cwd);
+                const firstErr = extractFirstTscError(buildOutput || '');
+                recordBuildIssue(pkg.name || path.basename(cwd), 'error', firstErr || 'Build failed');
                 if (!force) {
                     return false;
                 }
                 console.log(colors.yellow('Continuing with --force despite build failure...'));
             }
             else {
+                if (verbose && buildResult.output)
+                    process.stdout.write(buildResult.output);
                 console.log(`${timestamp()} ${colors.green('✓ Build succeeded')}`);
             }
         }
@@ -4000,25 +4112,20 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
             }
         }
         catch (e) {
-            // Ignore cleanup errors
+            console.error(colors.yellow(`  Warning: could not delete tarball ${tarballName} — remove manually`));
         }
         if (!publishResult.success) {
-            console.error(colors.red('\nERROR: npm publish failed\n'));
-            recordBuildIssue(pkg.name || path.basename(cwd), 'error', 'npm publish failed');
-            // Check for specific error types
+            // Check for specific error types before recording
             const output = (publishResult.output + '\n' + publishResult.stderr).toLowerCase();
-            if (output.includes('err_string_too_long') || output.includes('string longer than')) {
-                console.error(colors.red('Tarball too large — check .npmignore. Run: npm pack --dry-run'));
-            }
-            else if (output.includes('e409') || output.includes('409 conflict')) {
-                console.error(colors.yellow('npm still processing previous version — wait and retry'));
-            }
-            else if (output.includes('cannot publish over') || output.includes('previously published')) {
+            // "Already published" is benign — don't record as error
+            if (output.includes('cannot publish over') || output.includes('previously published')) {
                 const currentPkgVersion = readPackageJson(cwd).version;
                 if (output.includes(currentPkgVersion)) {
                     console.log(colors.green('✓ Already published — continuing'));
                 }
                 else {
+                    console.error(colors.red('\nERROR: npm publish failed\n'));
+                    recordBuildIssue(pkg.name || path.basename(cwd), 'error', 'npm publish failed');
                     console.error(colors.yellow('Version conflict — run npmglobalize again'));
                     if (transformResult.transformed) {
                         const failPkg = readPackageJson(cwd);
@@ -4030,7 +4137,19 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                     return false;
                 }
             }
+            else if (output.includes('err_string_too_long') || output.includes('string longer than')) {
+                console.error(colors.red('\nERROR: npm publish failed\n'));
+                recordBuildIssue(pkg.name || path.basename(cwd), 'error', 'npm publish failed');
+                console.error(colors.red('Tarball too large — check .npmignore. Run: npm pack --dry-run'));
+            }
+            else if (output.includes('e409') || output.includes('409 conflict')) {
+                console.error(colors.red('\nERROR: npm publish failed\n'));
+                recordBuildIssue(pkg.name || path.basename(cwd), 'error', 'npm publish failed');
+                console.error(colors.yellow('npm still processing previous version — wait and retry'));
+            }
             else if (output.includes('403') || output.includes('forbidden')) {
+                console.error(colors.red('\nERROR: npm publish failed\n'));
+                recordBuildIssue(pkg.name || path.basename(cwd), 'error', 'npm publish failed');
                 console.error(colors.yellow('Publish forbidden — check npm login and package access'));
                 if (transformResult.transformed) {
                     const failPkg = readPackageJson(cwd);
@@ -4042,9 +4161,13 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                 return false;
             }
             else if (output.includes('402') || output.includes('payment required')) {
+                console.error(colors.red('\nERROR: npm publish failed\n'));
+                recordBuildIssue(pkg.name || path.basename(cwd), 'error', 'npm publish failed');
                 console.error(colors.yellow('Private packages need paid npm account — use --npm public'));
             }
             else {
+                console.error(colors.red('\nERROR: npm publish failed\n'));
+                recordBuildIssue(pkg.name || path.basename(cwd), 'error', 'npm publish failed');
                 console.error(colors.yellow('Publish failed — run npm login or check npm whoami'));
             }
             if (transformResult.transformed) {
@@ -4526,6 +4649,7 @@ export default {
     getGitStatus,
     validatePackageJson,
     confirm,
-    initGit
+    initGit,
+    installCleanupHandlers
 };
 //# sourceMappingURL=lib.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.142",
+  "version": "1.0.144",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",
@@ -56,5 +56,19 @@
     "npm-registry-fetch": "^19.1.1",
     "pacote": "^21.0.4",
     "simple-git": "^3.30.0"
+  },
+  ".transformedSnapshot": {
+    "dependencies": {
+      "@bobfrankston/freezepak": "^0.1.6",
+      "@bobfrankston/importgen": "^0.1.32",
+      "@bobfrankston/themecolors": "^0.1.4",
+      "@bobfrankston/userconfig": "^1.0.6",
+      "@npmcli/package-json": "^7.0.4",
+      "json5": "^2.2.3",
+      "libnpmversion": "^8.0.3",
+      "npm-registry-fetch": "^19.1.1",
+      "pacote": "^21.0.4",
+      "simple-git": "^3.30.0"
+    }
   }
 }