@cloudbase/manager-node 4.2.12 → 4.3.1

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/checkGitDirEnv.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("./debug"));
+function checkGitDirEnv() {
+    if (process.env.GIT_DIR) {
+        debug_1.default(`GIT_DIR environment variable is set to '${process.env.GIT_DIR}'`);
+        debug_1.default(`If you're getting "fatal: not a git repository" errors, you may want to unset GIT_DIR`);
+    }
+}
+exports.checkGitDirEnv = checkGitDirEnv;

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/debug.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function debug(...args) {
+    if (['1', 'true'].includes(process.env.HUSKY_DEBUG || '')) {
+        console.log('husky:debug', ...args);
+    }
+}
+exports.default = debug;

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/getConf.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cosmiconfig_1 = __importDefault(require("cosmiconfig"));
+function getConf(dir) {
+    const explorer = cosmiconfig_1.default('husky');
+    const { config = {} } = explorer.searchSync(dir) || {};
+    const defaults = {
+        skipCI: true
+    };
+    return Object.assign(Object.assign({}, defaults), config);
+}
+exports.default = getConf;

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/installer/bin.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const ci_info_1 = require("ci-info");
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("../debug"));
+const _1 = require("./");
+const gitRevParse_1 = __importDefault(require("./gitRevParse"));
+const checkGitDirEnv_1 = require("../checkGitDirEnv");
+// Debug
+debug_1.default(`Current working directory is '${process.cwd()}'`);
+debug_1.default(`INIT_CWD environment variable is set to '${process.env.INIT_CWD}'`);
+// Action can be "install" or "uninstall"
+// huskyDir is ONLY used in dev, don't use this arguments
+const [, , action, huskyDir = path_1.default.join(__dirname, '../..')] = process.argv;
+// Find Git dir
+try {
+    // Show un/install message
+    console.log('husky > %s git hooks', action === 'install' ? 'Setting up' : 'Uninstalling');
+    // Skip install if HUSKY_SKIP_INSTALL=1
+    if (action === 'install' &&
+        ['1', 'true'].includes(process.env.HUSKY_SKIP_INSTALL || '')) {
+        console.log("HUSKY_SKIP_INSTALL environment variable is set to 'true',", 'skipping Git hooks installation.');
+        process.exit(0);
+    }
+    // Check GIT_DIR environment variable
+    checkGitDirEnv_1.checkGitDirEnv();
+    // Get top level and git dir
+    const { topLevel, gitCommonDir } = gitRevParse_1.default();
+    debug_1.default('Git rev-parse command returned:');
+    debug_1.default(`  --show-top-level: ${topLevel}`);
+    debug_1.default(`  --git-common-dir: ${gitCommonDir}`);
+    // Install or uninstall
+    if (action === 'install') {
+        _1.install(topLevel, gitCommonDir, huskyDir, ci_info_1.isCI);
+    }
+    else {
+        _1.uninstall(gitCommonDir, huskyDir);
+    }
+    console.log(`husky > Done`);
+}
+catch (error) {
+    console.log(chalk_1.default.red(error.message.trim()));
+    console.log(chalk_1.default.red(`husky > Failed to ${action}`));
+}

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/installer/getScript.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const slash_1 = __importDefault(require("slash"));
+// Used to identify scripts created by Husky
+exports.huskyIdentifier = '# husky';
+// Experimental
+const huskyrc = '~/.huskyrc';
+// Render script
+const render = ({ createdAt, homepage, node, pkgDirectory, pkgHomepage, platform, runScriptPath, version }) => `#!/bin/sh
+${exports.huskyIdentifier}
+
+# Hook created by Husky
+#   Version: ${version}
+#   At: ${createdAt}
+#   See: ${homepage}
+
+# From
+#   Directory: ${pkgDirectory}
+#   Homepage: ${pkgHomepage}
+
+scriptPath="${runScriptPath}.js"
+hookName=\`basename "$0"\`
+gitParams="$*"
+
+debug() {
+  if [ "$\{HUSKY_DEBUG}" = "true" ] || [ "$\{HUSKY_DEBUG}" = "1" ]; then
+    echo "husky:debug $1"
+  fi
+}
+
+debug "husky v${version} (created at ${createdAt})"
+debug "$hookName hook started"
+debug "Current working directory is '\`pwd\`'"
+
+if [ "$\{HUSKY_SKIP_HOOKS}" = "true" ] || [ "$\{HUSKY_SKIP_HOOKS}" = "1" ]; then
+  debug "HUSKY_SKIP_HOOKS is set to $\{HUSKY_SKIP_HOOKS}, skipping hook"
+  exit 0
+fi
+
+if [ "$\{HUSKY_USE_YARN}" = "true" ] || [ "$\{HUSKY_USE_YARN}" = "1" ]; then
+  debug "Calling husky through Yarn"
+  yarn husky-run $hookName "$gitParams"
+else
+${platform === 'win32'
+    ? ''
+    : `
+  if ! command -v node >/dev/null 2>&1; then
+    echo "Info: can't find node in PATH, trying to find a node binary on your system"
+  fi
+`}
+  if [ -f "$scriptPath" ]; then
+    # if [ -t 1 ]; then
+    #   exec < /dev/tty
+    # fi
+    if [ -f ${huskyrc} ]; then
+      debug "Sourcing '${huskyrc}'"
+      . ${huskyrc}
+    fi
+    ${node} "$scriptPath" $hookName "$gitParams"
+  else
+    echo "Can't find Husky, skipping $hookName hook"
+    echo "You can reinstall it using 'npm install husky --save-dev' or delete this hook"
+  fi
+fi
+`;
+/**
+ * @param {string} rootDir - e.g. /home/typicode/project/
+ * @param {string} huskyDir - e.g. /home/typicode/project/node_modules/husky/
+ * @param {string} requireRunNodePath - path to run-node resolved by require e.g. /home/typicode/project/node_modules/run-node/run-node
+ * @param {string} platform - platform husky installer is running on (used to produce win32 specific script)
+ * @returns {string} script
+ */
+function default_1(rootDir, huskyDir, requireRunNodePath, 
+// Additional param used for testing only
+platform = os_1.default.platform()) {
+    const runNodePath = slash_1.default(path_1.default.relative(rootDir, requireRunNodePath));
+    // On Windows do not rely on run-node
+    const node = platform === 'win32' ? 'node' : runNodePath;
+    // Env variable
+    const pkgHomepage = process && process.env && process.env.npm_package_homepage;
+    const pkgDirectory = process && process.env && process.env.PWD;
+    // Husky package.json
+    const { homepage, version } = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '../../package.json'), 'utf-8'));
+    // Path to run.js
+    const runScriptPath = slash_1.default(path_1.default.join(path_1.default.relative(rootDir, huskyDir), 'run'));
+    // Created at
+    const createdAt = new Date().toLocaleString();
+    // Render script
+    return render({
+        createdAt,
+        homepage,
+        node,
+        pkgDirectory,
+        pkgHomepage,
+        platform,
+        runScriptPath,
+        version
+    });
+}
+exports.default = default_1;

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/installer/gitRevParse.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const slash_1 = __importDefault(require("slash"));
+const execa_1 = __importDefault(require("execa"));
+function default_1() {
+    // https://github.com/typicode/husky/issues/580
+    // https://github.com/typicode/husky/issues/587
+    const result = execa_1.default.sync('git', [
+        'rev-parse',
+        '--show-toplevel',
+        '--git-common-dir'
+    ]);
+    const [topLevel, gitCommonDir] = result.stdout
+        .trim()
+        .split('\n')
+        // Normalize for Windows
+        .map(slash_1.default);
+    // Git rev-parse returns unknown options as is.
+    // If we get --absolute-git-dir in the output,
+    // it probably means that an older version of Git has been used.
+    if (gitCommonDir === '--git-common-dir') {
+        throw new Error('Husky requires Git >= 2.13.0, please upgrade Git');
+    }
+    return { topLevel, gitCommonDir };
+}
+exports.default = default_1;

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/installer/index.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const pkg_dir_1 = __importDefault(require("pkg-dir"));
+const getConf_1 = __importDefault(require("../getConf"));
+const getScript_1 = __importDefault(require("./getScript"));
+const is_1 = require("./is");
+const debug_1 = __importDefault(require("../debug"));
+const hookList = [
+    'applypatch-msg',
+    'pre-applypatch',
+    'post-applypatch',
+    'pre-commit',
+    'pre-merge-commit',
+    'prepare-commit-msg',
+    'commit-msg',
+    'post-commit',
+    'pre-rebase',
+    'post-checkout',
+    'post-merge',
+    'pre-push',
+    'pre-receive',
+    'update',
+    'post-receive',
+    'post-update',
+    'push-to-checkout',
+    'pre-auto-gc',
+    'post-rewrite',
+    'sendemail-validate'
+];
+function writeHook(filename, script) {
+    fs_1.default.writeFileSync(filename, script, 'utf-8');
+    fs_1.default.chmodSync(filename, 0o0755);
+}
+function createHook(filename, script) {
+    // Get name, used for logging
+    const name = path_1.default.basename(filename);
+    // Check if hook exist
+    if (fs_1.default.existsSync(filename)) {
+        const hook = fs_1.default.readFileSync(filename, 'utf-8');
+        // Migrate
+        if (is_1.isGhooks(hook)) {
+            console.log(`migrating existing ghooks script: ${name}`);
+            return writeHook(filename, script);
+        }
+        // Migrate
+        if (is_1.isPreCommit(hook)) {
+            console.log(`migrating existing pre-commit script: ${name}`);
+            return writeHook(filename, script);
+        }
+        // Update
+        if (is_1.isHusky(hook) || is_1.isYorkie(hook)) {
+            return writeHook(filename, script);
+        }
+        // Skip
+        console.log(`skipping existing user hook: ${name}`);
+        return;
+    }
+    // Create hook if it doesn't exist
+    writeHook(filename, script);
+}
+function createHooks(filenames, script) {
+    filenames.forEach((filename) => createHook(filename, script));
+}
+function canRemove(filename) {
+    if (fs_1.default.existsSync(filename)) {
+        const data = fs_1.default.readFileSync(filename, 'utf-8');
+        return is_1.isHusky(data);
+    }
+    return false;
+}
+function removeHook(filename) {
+    fs_1.default.unlinkSync(filename);
+}
+function removeHooks(filenames) {
+    filenames.filter(canRemove).forEach(removeHook);
+}
+// This prevents the case where someone would want to debug a node_module that has
+// husky as devDependency and run npm install from node_modules directory
+function isInNodeModules(dir) {
+    // INIT_CWD holds the full path you were in when you ran npm install (supported also by yarn and pnpm)
+    // See https://docs.npmjs.com/cli/run-script
+    if (process.env.INIT_CWD) {
+        return process.env.INIT_CWD.indexOf('node_modules') !== -1;
+    }
+    // Old technique
+    return (dir.match(/node_modules/g) || []).length > 1;
+}
+function getGitHooksDir(gitDir) {
+    return path_1.default.join(gitDir, 'hooks');
+}
+function getHooks(gitDir) {
+    const gitHooksDir = getGitHooksDir(gitDir);
+    return hookList.map((hookName) => path_1.default.join(gitHooksDir, hookName));
+}
+/**
+ * @param topLevel - as returned by git --rev-parse
+ * @param gitDir - as returned by git --rev-parse
+ * @param huskyDir - e.g. /home/typicode/project/node_modules/husky/
+ * @param isCI - true if running in CI
+ * @param requireRunNodePath - path to run-node resolved by require e.g. /home/typicode/project/node_modules/run-node/run-node
+ */
+// eslint-disable-next-line max-params
+function install(topLevel, gitDir, huskyDir, isCI, requireRunNodePath = require.resolve('run-node/run-node')) {
+    // First directory containing user's package.json
+    const userPkgDir = pkg_dir_1.default.sync(path_1.default.join(huskyDir, '..'));
+    if (userPkgDir === undefined) {
+        console.log("Can't find package.json, skipping Git hooks installation.");
+        console.log('Please check that your project has a package.json or create it and reinstall husky.');
+        return;
+    }
+    // Get conf from package.json or .huskyrc
+    const conf = getConf_1.default(userPkgDir);
+    // Checks
+    if (isCI && conf.skipCI) {
+        console.log('CI detected, skipping Git hooks installation.');
+        return;
+    }
+    if (isInNodeModules(huskyDir)) {
+        console.log('Trying to install from node_modules directory, skipping Git hooks installation.');
+        return;
+    }
+    // Create hooks directory if it doesn't exist
+    const gitHooksDir = getGitHooksDir(gitDir);
+    if (!fs_1.default.existsSync(gitHooksDir)) {
+        fs_1.default.mkdirSync(gitHooksDir);
+    }
+    debug_1.default(`Installing hooks in '${gitHooksDir}'`);
+    const hooks = getHooks(gitDir);
+    const script = getScript_1.default(topLevel, huskyDir, requireRunNodePath);
+    createHooks(hooks, script);
+}
+exports.install = install;
+function uninstall(gitDir, huskyDir) {
+    if (gitDir === null) {
+        console.log("Can't find resolved .git directory, skipping Git hooks uninstallation.");
+        return;
+    }
+    if (isInNodeModules(huskyDir)) {
+        console.log('Trying to uninstall from node_modules directory, skipping Git hooks uninstallation.');
+        return;
+    }
+    // Remove hooks
+    const hooks = getHooks(gitDir);
+    removeHooks(hooks);
+}
+exports.uninstall = uninstall;

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/installer/is.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getScript_1 = require("./getScript");
+function isHusky(data) {
+    // Husky v0.14 and prior used #husky as an identifier.
+    // Just in case some previous hooks weren't correctly uninstalled,
+    // and for a better transition this will allow v0.15+ to uninstall them as well.
+    const previousHuskyIdentifier = '#husky';
+    return (data.indexOf(getScript_1.huskyIdentifier) !== -1 ||
+        data.indexOf(previousHuskyIdentifier) !== -1);
+}
+exports.isHusky = isHusky;
+function isYorkie(data) {
+    return data.indexOf('#yorkie') !== -1;
+}
+exports.isYorkie = isYorkie;
+function isGhooks(data) {
+    return data.indexOf('// Generated by ghooks. Do not edit this file.') !== -1;
+}
+exports.isGhooks = isGhooks;
+function isPreCommit(data) {
+    return data.indexOf('./node_modules/pre-commit/hook') !== -1;
+}
+exports.isPreCommit = isPreCommit;

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/runner/bin.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = __importDefault(require("./"));
+const checkGitDirEnv_1 = require("../checkGitDirEnv");
+// Check GIT_DIR environment variable
+checkGitDirEnv_1.checkGitDirEnv();
+// Run hook
+_1.default(process.argv)
+    .then((status) => process.exit(status))
+    .catch((err) => {
+    console.log('Husky > unexpected error', err);
+    process.exit(1);
+});

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/runner/index.js

@@ -0,0 +1,84 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const execa_1 = __importDefault(require("execa"));
+const get_stdin_1 = __importDefault(require("get-stdin"));
+const path_1 = __importDefault(require("path"));
+const read_pkg_1 = __importDefault(require("read-pkg"));
+const debug_1 = __importDefault(require("../debug"));
+const getConf_1 = __importDefault(require("../getConf"));
+/**
+ * @param {array} argv - process.argv
+ * @param {promise} getStdinFn - used for mocking only
+ */
+function run([, scriptPath, hookName = '', HUSKY_GIT_PARAMS], getStdinFn = get_stdin_1.default) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Update CWD
+        const cwd = path_1.default.resolve(scriptPath.split('node_modules')[0]);
+        // Debug
+        debug_1.default(`Changed current working directory to '${cwd}'`);
+        // In some cases, package.json may not exist
+        // For example, when switching to gh-page branch
+        let pkg;
+        try {
+            pkg = read_pkg_1.default.sync({ cwd, normalize: false });
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+        }
+        const config = getConf_1.default(cwd);
+        const command = config && config.hooks && config.hooks[hookName];
+        const oldCommand = pkg && pkg.scripts && pkg.scripts[hookName.replace('-', '')];
+        // Run command
+        try {
+            const env = {};
+            if (HUSKY_GIT_PARAMS) {
+                env.HUSKY_GIT_PARAMS = HUSKY_GIT_PARAMS;
+            }
+            if (['pre-push', 'pre-receive', 'post-receive', 'post-rewrite'].includes(hookName)) {
+                // Wait for stdin
+                env.HUSKY_GIT_STDIN = yield getStdinFn();
+            }
+            if (oldCommand) {
+                console.log();
+                console.log(`Warning: Setting ${hookName} script in package.json > scripts will be deprecated`);
+                console.log(`Please move it to husky.hooks in package.json, a .huskyrc file, or a husky.config.js file`);
+                console.log(`Or run ./node_modules/.bin/husky-upgrade for automatic update`);
+                console.log();
+                console.log(`See https://github.com/typicode/husky for usage`);
+                console.log();
+            }
+            if (command || oldCommand) {
+                console.log(`husky > ${hookName} (node ${process.version})`);
+                execa_1.default.shellSync(command || oldCommand, { cwd, env, stdio: 'inherit' });
+            }
+            return 0;
+        }
+        catch (err) {
+            const noVerifyMessage = [
+                'commit-msg',
+                'pre-commit',
+                'pre-rebase',
+                'pre-push'
+            ].includes(hookName)
+                ? '(add --no-verify to bypass)'
+                : '(cannot be bypassed with --no-verify due to Git specs)';
+            console.log(`husky > ${hookName} hook failed ${noVerifyMessage}`);
+            return err.code;
+        }
+    });
+}
+exports.default = run;

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/upgrader/bin.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+index_1.default(process.cwd());

package/.yarn/unplugged/husky-npm-3.1.0-5cc13e4e34/node_modules/husky/lib/upgrader/index.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const read_pkg_1 = __importDefault(require("read-pkg"));
+const hookList = {
+    applypatchmsg: 'applypatch-msg',
+    commitmsg: 'commit-msg',
+    postapplypatch: 'post-applypatch',
+    postcheckout: 'post-checkout',
+    postcommit: 'post-commit',
+    postmerge: 'post-merge',
+    postreceive: 'post-receive',
+    postrewrite: 'post-rewrite',
+    postupdate: 'post-update',
+    preapplypatch: 'pre-applypatch',
+    preautogc: 'pre-auto-gc',
+    precommit: 'pre-commit',
+    premergecommit: 'pre-merge-commit',
+    preparecommitmsg: 'prepare-commit-msg',
+    prepush: 'pre-push',
+    prerebase: 'pre-rebase',
+    prereceive: 'pre-receive',
+    pushtocheckout: 'push-to-checkout',
+    sendemailvalidate: 'sendemail-validate',
+    update: 'update'
+};
+function upgrade(cwd) {
+    const pkgFile = path_1.default.join(cwd, 'package.json');
+    if (fs_1.default.existsSync(pkgFile)) {
+        const pkg = read_pkg_1.default.sync({ cwd, normalize: false });
+        console.log(`husky > upgrading ${pkgFile}`);
+        // Don't overwrite 'husky' field if it exists
+        if (pkg.husky) {
+            return console.log(`husky field in package.json isn't empty, skipping automatic upgrade`);
+        }
+        const hooks = {};
+        // Find hooks in package.json 'scripts' field
+        Object.keys(hookList).forEach((name) => {
+            if (pkg.scripts) {
+                const script = pkg.scripts[name];
+                if (script) {
+                    delete pkg.scripts[name];
+                    const newName = hookList[name];
+                    hooks[newName] = script.replace(/\bGIT_PARAMS\b/g, 'HUSKY_GIT_PARAMS');
+                    console.log(`moved scripts.${name} to husky.hooks.${newName}`);
+                }
+            }
+        });
+        // Move found hooks to 'husky.hooks' field
+        if (Object.keys(hooks).length) {
+            pkg.husky = { hooks };
+        }
+        else {
+            console.log('no hooks found');
+        }
+        // Update package.json
+        fs_1.default.writeFileSync(pkgFile, `${JSON.stringify(pkg, null, 2)}\n`, 'utf-8');
+        console.log(`husky > done`);
+    }
+}
+exports.default = upgrade;