@bobfrankston/npmglobalize 1.0.117 → 1.0.119

package/lib/config.d.ts

@@ -0,0 +1,23 @@
+import { type NpmCommonConfig } from '@bobfrankston/userconfig';
+import { type GlobalizeOptions } from './types.js';
+/** Read and parse package.json from a directory */
+export declare function readPackageJson(dir: string): any;
+/** Global npm config from %USERPROFILE%\.userconfig\npm.json5 — via @bobfrankston/userconfig */
+export type UserNpmConfig = NpmCommonConfig;
+/** Get the .userconfig directory path (%USERPROFILE%\.userconfig) */
+export declare function getUserConfigDir(): string;
+/** Read global npm config from %USERPROFILE%\.userconfig\npm.json5 */
+export declare function readUserNpmConfig(): UserNpmConfig;
+/** Write global npm config to %USERPROFILE%\.userconfig\npm.json5 */
+export declare function writeUserNpmConfig(config: UserNpmConfig): void;
+/** Read .globalize.json5 config file */
+export declare function readConfig(dir: string): Partial<GlobalizeOptions>;
+/** Write .globalize.json5 config file */
+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;
+/** 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 */
+export declare function isFileRef(value: string): boolean;
+//# sourceMappingURL=config.d.ts.map

package/lib/config.js

@@ -0,0 +1,159 @@
+import fs from 'fs';
+import path from 'path';
+import JSON5 from 'json5';
+import { readConfig as readUserConfig, writeConfig as writeUserConfig, configDir } from '@bobfrankston/userconfig';
+/** Read and parse package.json from a directory */
+export function readPackageJson(dir) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        throw new Error(`package.json not found: ${pkgPath}`);
+    }
+    try {
+        return JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${pkgPath}: ${error.message}`);
+    }
+}
+/** Get the .userconfig directory path (%USERPROFILE%\.userconfig) */
+export function getUserConfigDir() {
+    return configDir;
+}
+/** Read global npm config from %USERPROFILE%\.userconfig\npm.json5 */
+export function readUserNpmConfig() {
+    return readUserConfig();
+}
+/** Write global npm config to %USERPROFILE%\.userconfig\npm.json5 */
+export function writeUserNpmConfig(config) {
+    const existing = readUserConfig();
+    const merged = { ...existing, ...config };
+    writeUserConfig(merged);
+}
+/** Read .globalize.json5 config file */
+export function readConfig(dir) {
+    const configPath = path.join(dir, '.globalize.json5');
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON5.parse(content);
+    }
+    catch (error) {
+        console.warn(`Warning: Could not parse .globalize.json5 config: ${error.message}`);
+        return {};
+    }
+}
+/** Write .globalize.json5 config file */
+export function writeConfig(dir, config, explicitKeys) {
+    const configPath = path.join(dir, '.globalize.json5');
+    // Define defaults to omit
+    const defaults = {
+        bump: 'patch',
+        files: true,
+        quiet: true,
+        gitVisibility: 'private',
+        npmVisibility: 'private',
+        install: false,
+        wsl: false,
+        force: false,
+        verbose: false,
+        freeze: false
+    };
+    // Read existing config to preserve values
+    const existing = readConfig(dir);
+    // Filter out temporary flags and default values (unless explicitly set)
+    const filtered = {};
+    const omitKeys = new Set(['cleanup', 'init', 'dryRun', 'message', 'conform', 'asis', 'help', 'error', 'updateDeps', 'updateMajor', 'publishDeps', 'forcePublish', 'once']);
+    for (const [key, value] of Object.entries(config)) {
+        if (omitKeys.has(key))
+            continue;
+        // Keep if: already in config, explicitly set via CLI, or differs from default
+        const isExplicit = explicitKeys?.has(key);
+        const wasInConfig = key in existing;
+        const differsFromDefault = defaults[key] !== value;
+        if (isExplicit || wasInConfig || differsFromDefault) {
+            filtered[key] = value;
+        }
+    }
+    // Build content with comments
+    const lines = [
+        '{',
+        '  // npmglobalize configuration (JSON5 format - trailing commas OK)',
+        '  // Explicitly set values are preserved here',
+        ''
+    ];
+    // Add configured values
+    const entries = Object.entries(filtered);
+    if (entries.length > 0) {
+        entries.forEach(([key, value]) => {
+            const jsonValue = typeof value === 'string' ? `"${value}"` : JSON.stringify(value);
+            const comma = ','; // JSON5 allows trailing commas
+            // Add inline comment for clarity
+            let comment = '';
+            if (key === 'install')
+                comment = '  // Auto-install globally after publish (from registry)';
+            else if (key === 'link')
+                comment = '  // Install globally via symlink (npm install -g .)';
+            else if (key === 'wsl')
+                comment = '  // Also install in WSL';
+            else if (key === 'files')
+                comment = '  // Keep file: paths after publish';
+            else if (key === 'force')
+                comment = '  // Continue despite git errors';
+            else if (key === 'quiet')
+                comment = '  // Suppress npm warnings';
+            else if (key === 'verbose')
+                comment = '  // Show detailed output';
+            else if (key === 'gitVisibility')
+                comment = '  // private (default) or public';
+            else if (key === 'npmVisibility')
+                comment = '  // private (default) or public';
+            else if (key === 'bump')
+                comment = '  // patch (default), minor, or major';
+            else if (key === 'fix')
+                comment = '  // Auto-run npm audit fix';
+            else if (key === 'local')
+                comment = '  // Local install only (skip transform/publish)';
+            else if (key === 'noPublish')
+                comment = '  // Transform but don\'t publish';
+            else if (key === 'freeze')
+                comment = '  // Freeze node_modules (replace symlinks with real copies)';
+            lines.push(`  "${key}": ${jsonValue}${comma}${comment}`);
+        });
+        lines.push('');
+    }
+    // Add commented reference for all options
+    lines.push('  // Defaults (omitted above):');
+    lines.push('  // "bump": "patch"              // Version bump: patch, minor, major');
+    lines.push('  // "install": false             // Auto-install globally after publish (from registry)');
+    lines.push('  // "link": false               // Install globally via symlink (npm install -g .)');
+    lines.push('  // "wsl": false                 // Also install in WSL');
+    lines.push('  // "files": true                // Keep file: paths after publish');
+    lines.push('  // "force": false               // Continue despite git errors');
+    lines.push('  // "quiet": true                // Suppress npm warnings');
+    lines.push('  // "verbose": false             // Show detailed output');
+    lines.push('  // "gitVisibility": "private"   // Git repo: private or public');
+    lines.push('  // "npmVisibility": "private"   // npm package: private or public');
+    lines.push('  // "fix": false                 // Auto-run npm audit fix');
+    lines.push('  // "local": false              // Local install only (skip transform/publish)');
+    lines.push('  // "noPublish": false          // Transform but don\'t publish');
+    lines.push('  // "freeze": false              // Freeze node_modules (replace symlinks with real copies)');
+    lines.push('}');
+    fs.writeFileSync(configPath, lines.join('\n') + '\n');
+}
+/** 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');
+}
+/** Resolve a file: path to absolute path */
+export function resolveFilePath(fileRef, baseDir) {
+    const relativePath = fileRef.replace(/^file:/, '');
+    return path.resolve(baseDir, relativePath);
+}
+/** Check if a dependency value is a file: reference */
+export function isFileRef(value) {
+    return typeof value === 'string' && value.startsWith('file:');
+}
+//# sourceMappingURL=config.js.map

package/lib/deps.d.ts

@@ -0,0 +1,42 @@
+/**
+ * npmglobalize dependency analysis, transformation, and restoration.
+ * Handles file: ref discovery, workspace graphs, topological sorting,
+ * and transforming file: deps to npm versions for publishing.
+ */
+/** Get all file: dependencies from package.json */
+export declare function getFileRefs(pkg: any): Map<string, {
+    key: string;
+    name: string;
+    value: string;
+}>;
+/** Resolve workspace entries to package info. Skips dirs without package.json or with private:true. */
+export declare function resolveWorkspacePackages(rootDir: string): Array<{
+    name: string;
+    dir: string;
+    pkg: any;
+}>;
+/** Build a dependency graph among workspace packages. Returns Map<name, Set<depName>>. */
+export declare function buildDependencyGraph(packages: Array<{
+    name: string;
+    dir: string;
+    pkg: any;
+}>): Map<string, Set<string>>;
+/** Topological sort with cycle detection. Returns package names in dependency order. */
+export declare function topologicalSort(graph: Map<string, Set<string>>): string[];
+/** Transform file: dependencies to npm versions */
+export declare function transformDeps(pkg: any, baseDir: string, verbose?: boolean, forcePublish?: boolean): {
+    transformed: boolean;
+    unpublished: Array<{
+        name: string;
+        version: string;
+        path: string;
+    }>;
+};
+/** Build and print a dependency tree of file: references.
+ *  Recursively walks file: deps showing the full hierarchy with indentation. */
+export declare function printDepTree(baseDir: string, indent?: number, visited?: Set<string>): void;
+/** Restore file: dependencies from .dependencies */
+export declare function restoreDeps(pkg: any, verbose?: boolean): boolean;
+/** Check if .dependencies exist (already transformed) */
+export declare function hasBackup(pkg: any): boolean;
+//# sourceMappingURL=deps.d.ts.map

package/lib/deps.js

@@ -0,0 +1,298 @@
+/**
+ * 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

@@ -0,0 +1,83 @@
+/**
+ * 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 */
+export declare function waitForNpmVersion(pkgName: string, version: string, maxWaitMs?: number): boolean;
+/** Run npm install -g with retries for registry propagation delay */
+export declare function installGlobalWithRetry(pkgSpec: string, cwd: string, 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