@bobfrankston/npmglobalize 1.0.199 → 1.0.201

package/lib/deps.js

@@ -1,298 +0,0 @@
-/**
- * npmglobalize dependency analysis, transformation, and restoration.
- * Handles file: ref discovery, workspace graphs, topological sorting,
- * and transforming file: deps to npm versions for publishing.
- */
-import fs from 'fs';
-import path from 'path';
-import { spawnSafe, colors, DEP_KEYS } from './types.js';
-import { readPackageJson, isFileRef, resolveFilePath } from './config.js';
-import { checkVersionExists } from './npm.js';
-/** Get all file: dependencies from package.json */
-export function getFileRefs(pkg) {
-    const refs = new Map();
-    for (const key of DEP_KEYS) {
-        if (!pkg[key])
-            continue;
-        for (const [name, value] of Object.entries(pkg[key])) {
-            if (isFileRef(value)) {
-                refs.set(`${key}:${name}`, { key, name, value: value });
-            }
-        }
-    }
-    return refs;
-}
-// ─── Workspace helpers ───────────────────────────────────────────────
-/** Resolve workspace entries to package info. Skips dirs without package.json or with private:true. */
-export function resolveWorkspacePackages(rootDir) {
-    const rootPkg = readPackageJson(rootDir);
-    const workspaces = rootPkg.workspaces;
-    if (!Array.isArray(workspaces))
-        return [];
-    const results = [];
-    for (const entry of workspaces) {
-        const pkgDir = path.resolve(rootDir, entry);
-        const pkgJsonPath = path.join(pkgDir, 'package.json');
-        if (!fs.existsSync(pkgJsonPath))
-            continue;
-        const pkg = readPackageJson(pkgDir);
-        if (pkg.private)
-            continue; // skip private packages (they can't be published)
-        results.push({ name: pkg.name || entry, dir: pkgDir, pkg });
-    }
-    return results;
-}
-/** Build a dependency graph among workspace packages. Returns Map<name, Set<depName>>. */
-export function buildDependencyGraph(packages) {
-    const nameSet = new Set(packages.map(p => p.name));
-    const dirToName = new Map();
-    for (const p of packages) {
-        dirToName.set(p.dir, p.name);
-    }
-    const graph = new Map();
-    for (const p of packages) {
-        const deps = new Set();
-        for (const depKey of DEP_KEYS) {
-            if (!p.pkg[depKey])
-                continue;
-            for (const [depName, depValue] of Object.entries(p.pkg[depKey])) {
-                // Check by npm name
-                if (nameSet.has(depName)) {
-                    deps.add(depName);
-                    continue;
-                }
-                // Check file: refs that resolve to a sibling workspace dir
-                if (isFileRef(depValue)) {
-                    const resolved = resolveFilePath(depValue, p.dir);
-                    const resolvedNorm = path.resolve(resolved);
-                    const match = dirToName.get(resolvedNorm);
-                    if (match) {
-                        deps.add(match);
-                    }
-                }
-            }
-        }
-        graph.set(p.name, deps);
-    }
-    return graph;
-}
-/** Topological sort with cycle detection. Returns package names in dependency order. */
-export function topologicalSort(graph) {
-    const visited = new Set();
-    const visiting = new Set(); // cycle detection
-    const result = [];
-    function visit(node) {
-        if (visited.has(node))
-            return;
-        if (visiting.has(node)) {
-            throw new Error(`Circular dependency detected involving: ${node}`);
-        }
-        visiting.add(node);
-        const deps = graph.get(node);
-        if (deps) {
-            for (const dep of deps) {
-                if (dep === node)
-                    continue; // skip self-references
-                if (graph.has(dep)) { // only visit workspace-internal deps
-                    visit(dep);
-                }
-            }
-        }
-        visiting.delete(node);
-        visited.add(node);
-        result.push(node);
-    }
-    for (const node of graph.keys()) {
-        visit(node);
-    }
-    return result;
-}
-/** Check if a published npm package has broken deps (file: paths or unpublished transitive deps).
- *  Also checks local file: deps for unpublished versions. */
-function hasUnpublishedTransitiveDeps(packageName, pkg, baseDir, verbose) {
-    // Check 1: Does the npm-published version have file: paths in its deps?
-    try {
-        const result = spawnSafe('npm', ['view', packageName, 'dependencies', '--json'], {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            shell: true
-        });
-        if (result.status === 0 && result.stdout.trim()) {
-            const npmDeps = JSON.parse(result.stdout.trim());
-            for (const [depName, depValue] of Object.entries(npmDeps)) {
-                if (isFileRef(depValue)) {
-                    if (verbose) {
-                        console.log(colors.yellow(`    npm copy has file: dep ${depName} → ${depValue}`));
-                    }
-                    return true;
-                }
-            }
-        }
-    }
-    catch {
-        // Can't check npm — fall through to local check
-    }
-    // Check 2: Do local file: deps have unpublished versions?
-    for (const key of DEP_KEYS) {
-        if (!pkg[key])
-            continue;
-        for (const [depName, depValue] of Object.entries(pkg[key])) {
-            if (!isFileRef(depValue))
-                continue;
-            try {
-                const depPath = resolveFilePath(depValue, baseDir);
-                const depPkg = readPackageJson(depPath);
-                if (!checkVersionExists(depName, depPkg.version)) {
-                    if (verbose) {
-                        console.log(colors.yellow(`    transitive dep ${depName}@${depPkg.version} not on npm`));
-                    }
-                    return true;
-                }
-            }
-            catch {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/** Transform file: dependencies to npm versions */
-export function transformDeps(pkg, baseDir, verbose = false, forcePublish = false) {
-    let transformed = false;
-    const unpublished = [];
-    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] };
-        }
-        // Transform file: refs to npm versions
-        for (const [name, value] of Object.entries(pkg[key])) {
-            if (isFileRef(value)) {
-                const targetPath = resolveFilePath(value, baseDir);
-                console.log(colors.blue(`  + ${name} → ${value}`));
-                try {
-                    const targetPkg = readPackageJson(targetPath);
-                    const targetVersion = targetPkg.version;
-                    const npmVersion = '^' + targetVersion;
-                    // Check if this version exists on npm (or if force publish)
-                    const versionExists = forcePublish ? false : checkVersionExists(name, targetVersion);
-                    if (!versionExists) {
-                        unpublished.push({ name, version: targetVersion, path: targetPath });
-                        if (forcePublish) {
-                            console.log(colors.yellow(`  ⟳ ${name}@${targetVersion} will be republished (--force-publish)`));
-                        }
-                        else {
-                            console.log(colors.red(`  ⚠ ${name}@${targetVersion} not found on npm (local: ${value})`));
-                        }
-                    }
-                    else {
-                        if (verbose) {
-                            console.log(colors.green(`  ✓ ${name}@${targetVersion} exists on npm`));
-                        }
-                        // Check transitive file: deps — if any are unpublished, this dep needs republishing
-                        if (hasUnpublishedTransitiveDeps(name, targetPkg, targetPath, verbose)) {
-                            unpublished.push({ name, version: targetVersion, path: targetPath });
-                            console.log(colors.yellow(`  ⟳ ${name}@${targetVersion} has unpublished transitive deps — will republish`));
-                        }
-                    }
-                    pkg[key][name] = npmVersion;
-                    if (verbose) {
-                        console.log(`  ${name}: ${value} -> ${npmVersion}`);
-                    }
-                    transformed = true;
-                }
-                catch (error) {
-                    throw new Error(`Failed to resolve ${name} at ${targetPath}: ${error.message}`);
-                }
-            }
-        }
-    }
-    return { transformed, unpublished };
-}
-/** Build and print a dependency tree of file: references.
- *  Recursively walks file: deps showing the full hierarchy with indentation. */
-export function printDepTree(baseDir, indent = 0, visited = new Set()) {
-    const realDir = fs.realpathSync(baseDir);
-    if (visited.has(realDir))
-        return;
-    visited.add(realDir);
-    let pkg;
-    try {
-        pkg = readPackageJson(baseDir);
-    }
-    catch {
-        return;
-    }
-    for (const key of DEP_KEYS) {
-        if (!pkg[key])
-            continue;
-        // Use the backup (.dependencies) if present — it has the original file: refs
-        const deps = pkg['.' + key] || pkg[key];
-        for (const [name, value] of Object.entries(deps)) {
-            if (!isFileRef(value))
-                continue;
-            const prefix = ' '.repeat(indent * 2);
-            let targetPath;
-            let version = '?';
-            try {
-                targetPath = resolveFilePath(value, baseDir);
-                const targetPkg = readPackageJson(targetPath);
-                version = targetPkg.version || '?';
-            }
-            catch {
-                console.log(`${prefix}  ${name} → ${value} ${colors.red('(unresolvable)')}`);
-                continue;
-            }
-            const exists = checkVersionExists(name, version);
-            const marker = exists ? colors.green('✓') : colors.red('✗');
-            console.log(`${prefix}  ${marker} ${name}@${version} → ${value}`);
-            printDepTree(targetPath, indent + 1, visited);
-        }
-    }
-}
-/** Restore file: dependencies from .dependencies */
-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;
-}
-/** Check if .dependencies exist (already transformed) */
-export function hasBackup(pkg) {
-    return DEP_KEYS.some(key => pkg['.' + key]);
-}
-//# sourceMappingURL=deps.js.map

package/lib/git.d.ts

@@ -1,91 +0,0 @@
-/**
- * npmglobalize — Git operations, command execution, and push protection.
- * Depends on: types (leaf), config (leaf)
- */
-import { type GitStatus } from './types.js';
-/**
- * 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.
- */
-export declare function removeNulFiles(dir: string, visited?: Set<string>): number;
-/** Repair a corrupted git index by rebuilding it.
- *  Handles "invalid object" / "Error building trees" errors caused by
- *  stale entries in .git/index referencing missing objects. */
-export declare function repairGitIndex(cwd: string): boolean;
-/** Parse file paths from git add "Permission denied" / "unable to index file" errors.
- *  Matches lines like: error: open("data/PingDB.mdf"): Permission denied
- *                  and: error: unable to index file 'data/PingDB.mdf' */
-export declare function parseDeniedFiles(errText: string): string[];
-/** Run a command and return success status */
-export declare function runCommand(cmd: string, args: string[], options?: {
-    silent?: boolean;
-    verbose?: boolean;
-    showCommand?: boolean;
-    cwd?: string;
-}): {
-    success: boolean;
-    output: string;
-    stderr: string;
-};
-/** Extract GitHub repo identifier from repository field */
-export declare function getGitHubRepo(pkg: any): string | null;
-/** Run a command and throw on failure */
-export declare function runCommandOrThrow(cmd: string, args: string[], options?: {
-    silent?: boolean;
-    cwd?: string;
-}): string;
-export declare function getGitStatus(cwd: string): GitStatus;
-/** Validate package.json for release */
-export declare function validatePackageJson(pkg: any): string[];
-/** Get the latest git tag (if any) */
-export declare function getLatestGitTag(cwd: string): string | null;
-/** Check if a git tag exists */
-export declare function gitTagExists(cwd: string, tag: string): boolean;
-/** Delete a git tag */
-export declare function deleteGitTag(cwd: string, tag: string): boolean;
-/** Get all git tags */
-export declare function getAllGitTags(cwd: string): string[];
-/** Parse version from tag (e.g., 'v1.2.3' -> [1, 2, 3]) */
-export declare function parseVersionTag(tag: string): number[] | null;
-/** Compare two version arrays (returns -1 if a < b, 0 if equal, 1 if a > b) */
-export declare function compareVersions(a: number[], b: number[]): number;
-/** Fix version/tag mismatches */
-export declare function fixVersionTagMismatch(cwd: string, pkg: any, verbose?: boolean): boolean;
-/** 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,
- *  so the registry/CDN can take several minutes before the package is
- *  resolvable. We wait longer and re-probe `npm view` for the version
- *  string until it shows up (or we hit the cap). */
-export declare function waitForNpmVersion(pkgName: string, version: string, isNewPackage?: boolean, maxWaitMs?: number): boolean;
-/** Run npm install -g with retries for registry propagation delay.
- *  Brand-new packages (first-time publish) take much longer to become
- *  installable than version bumps, so we use longer waits and more
- *  attempts when `isNewPackage` is true. */
-export declare function installGlobalWithRetry(pkgSpec: string, cwd: string, isNewPackage?: boolean, maxRetries?: number): {
-    success: boolean;
-    output: string;
-    stderr: string;
-};
-/** Detect OAuth credentials.json type: "installed" (public app ID, safe to include) or "web" (has real secret, must ignore).
- *  Returns null if no credentials.json exists or it can't be parsed. */
-export declare function detectCredentialsType(cwd: string): 'installed' | 'web' | null;
-interface PushProtectionSecret {
-    type: string;
-    file: string;
-    unblockUrl: string;
-}
-interface PushProtectionInfo {
-    detected: boolean;
-    secrets: PushProtectionSecret[];
-    allInstalledOAuth: boolean;
-}
-/** Parse GitHub push protection (GH013) error output and extract secret details + unblock URLs. */
-export declare function parsePushProtection(errorOutput: string, cwd: string): PushProtectionInfo;
-/** Display push protection guidance based on the type of secrets detected. */
-export declare function showPushProtectionGuidance(ppInfo: PushProtectionInfo): void;
-/** Push to git with push-protection detection and auto-bypass for installed OAuth.
- *  Returns true if push succeeded (possibly after auto-bypass). */
-export declare function pushWithProtection(cwd: string, verbose: boolean): boolean;
-export {};
-//# sourceMappingURL=git.d.ts.map