repo-tools/dist/cli.js

Useful commands to work with remote repositories

#!/usr/bin/env node
"use strict";
function _array_like_to_array(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
    return arr2;
}
function _array_with_holes(arr) {
    if (Array.isArray(arr)) return arr;
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
    try {
        var info = gen[key](arg);
        var value = info.value;
    } catch (error) {
        reject(error);
        return;
    }
    if (info.done) {
        resolve(value);
    } else {
        Promise.resolve(value).then(_next, _throw);
    }
}
function _async_to_generator(fn) {
    return function() {
        var self = this, args = arguments;
        return new Promise(function(resolve, reject) {
            var gen = fn.apply(self, args);
            function _next(value) {
                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
            }
            function _throw(err) {
                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
            }
            _next(undefined);
        });
    };
}
function _iterable_to_array_limit(arr, i) {
    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
    if (_i == null) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _s, _e;
    try {
        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
            _arr.push(_s.value);
            if (i && _arr.length === i) break;
        }
    } catch (err) {
        _d = true;
        _e = err;
    } finally{
        try {
            if (!_n && _i["return"] != null) _i["return"]();
        } finally{
            if (_d) throw _e;
        }
    }
    return _arr;
}
function _non_iterable_rest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _sliced_to_array(arr, i) {
    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
}
function _unsupported_iterable_to_array(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _array_like_to_array(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(n);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
function _ts_generator(thisArg, body) {
    var f, y, t, g, _ = {
        label: 0,
        sent: function() {
            if (t[0] & 1) throw t[1];
            return t[1];
        },
        trys: [],
        ops: []
    };
    return(g = {
        next: verb(0),
        "throw": verb(1),
        "return": verb(2)
    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
        return this;
    }), g);
    function verb(n) {
        return function(v) {
            return step([
                n,
                v
            ]);
        };
    }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while(_)try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [
                op[0] & 2,
                t.value
            ];
            switch(op[0]){
                case 0:
                case 1:
                    t = op;
                    break;
                case 4:
                    _.label++;
                    return {
                        value: op[1],
                        done: false
                    };
                case 5:
                    _.label++;
                    y = op[1];
                    op = [
                        0
                    ];
                    continue;
                case 7:
                    op = _.ops.pop();
                    _.trys.pop();
                    continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                        _ = 0;
                        continue;
                    }
                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
                        _.label = op[1];
                        break;
                    }
                    if (op[0] === 6 && _.label < t[1]) {
                        _.label = t[1];
                        t = op;
                        break;
                    }
                    if (t && _.label < t[2]) {
                        _.label = t[2];
                        _.ops.push(op);
                        break;
                    }
                    if (t[2]) _.ops.pop();
                    _.trys.pop();
                    continue;
            }
            op = body.call(thisArg, _);
        } catch (e) {
            op = [
                6,
                e
            ];
            y = 0;
        } finally{
            f = t = 0;
        }
        if (op[0] & 5) throw op[1];
        return {
            value: op[0] ? op[1] : void 0,
            done: true
        };
    }
}
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = function(target, all) {
    for(var name in all)__defProp(target, name, {
        get: all[name],
        enumerable: true
    });
};
var __copyProps = function(to, from, except, desc) {
    if (from && typeof from === "object" || typeof from === "function") {
        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
        try {
            var _loop = function() {
                var key = _step.value;
                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
                    get: function() {
                        return from[key];
                    },
                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
                });
            };
            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
        } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
        } finally{
            try {
                if (!_iteratorNormalCompletion && _iterator.return != null) {
                    _iterator.return();
                }
            } finally{
                if (_didIteratorError) {
                    throw _iteratorError;
                }
            }
        }
    }
    return to;
};
var __toESM = function(mod, isNodeMode, target) {
    return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
        value: mod,
        enumerable: true
    }) : target, mod);
};
var __toCommonJS = function(mod) {
    return __copyProps(__defProp({}, "__esModule", {
        value: true
    }), mod);
};
// src/cli.ts
var cli_exports = {};
__export(cli_exports, {
    default: function() {
        return cli_default;
    },
    tools: function() {
        return tools;
    }
});
module.exports = __toCommonJS(cli_exports);
var yargs = __toESM(require("yargs"));
// src/commands/check-remote.ts
var check_remote_exports = {};
__export(check_remote_exports, {
    command: function() {
        return command;
    },
    describe: function() {
        return describe;
    },
    handler: function() {
        return handler;
    }
});
var import_kolorist = require("kolorist");
// src/helpers.ts
var import_child_process = require("child_process");
var import_fs = require("fs");
var import_path = require("path");
var import_util = require("util");
var run = (0, import_util.promisify)(import_child_process.exec);
var getVersion = function() {
    var packagePath = (0, import_path.join)(process.cwd(), "package.json");
    if (!(0, import_fs.existsSync)(packagePath)) {
        return "--";
    }
    var packageSrc = (0, import_fs.readFileSync)(packagePath, "utf8");
    var version = JSON.parse(packageSrc).version;
    return version;
};
// src/commands/check-remote.ts
var command = "check-remote";
var describe = "Check if repo has remote commits";
var handler = function() {
    return run("git rev-parse --is-inside-work-tree").then(function() {
        return run("git ls-remote --exit-code --heads").then(function() {
            return Promise.all([
                run("git rev-parse @"),
                run("git rev-parse @{u}"),
                run("git merge-base @ @{u}")
            ]).then(function(values) {
                var _values = _sliced_to_array(values, 3), _values_ = _values[0], $local = _values_.stdout, _values_1 = _values[1], $remote = _values_1.stdout, _values_2 = _values[2], $base = _values_2.stdout;
                if ($local === $remote) {
                    console.log((0, import_kolorist.green)("✔ Repo is up-to-date!"));
                } else if ($local === $base) {
                    console.log((0, import_kolorist.red)("⊘ You need to pull, there are new commits."));
                    process.exit(1);
                }
            }).catch(function(error) {
                if (error.message.includes("no upstream configured ")) {
                    console.log((0, import_kolorist.yellow)("⚠ No upstream"));
                } else if (error.message.includes("fatal: ambiguous argument '@'")) {
                    console.log((0, import_kolorist.yellow)("⚠ No local commits"));
                } else {
                    console.log((0, import_kolorist.yellow)("⚠ Warning: ".concat(error.message)));
                }
            });
        }).catch(function() {
            console.log((0, import_kolorist.yellow)("⚠ No remote"));
        });
    }).catch(function() {
        console.log((0, import_kolorist.yellow)("⚠ not under git"));
    });
};
// src/commands/install-packages.ts
var install_packages_exports = {};
__export(install_packages_exports, {
    command: function() {
        return command2;
    },
    describe: function() {
        return describe2;
    },
    handler: function() {
        return handler2;
    }
});
var import_child_process2 = require("child_process");
var import_detect_package_manager = require("detect-package-manager");
var import_kolorist2 = require("kolorist");
var command2 = "install-packages";
var describe2 = "Run `npm/yarn/pnpm/bun install` if package.json has changed";
var install = function() {
    var pm = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "npm";
    var _stdout;
    console.log((0, import_kolorist2.yellow)('▼ package.json is modified. Running "'.concat(pm, ' install"...')));
    (_stdout = (0, import_child_process2.exec)("".concat(pm, " install")).stdout) === null || _stdout === void 0 ? void 0 : _stdout.pipe(process.stdout);
};
var handler2 = function() {
    var _ref = _async_to_generator(function() {
        var stdout, pm, e;
        return _ts_generator(this, function(_state) {
            switch(_state.label){
                case 0:
                    return [
                        4,
                        run("git diff-tree -r --name-only --no-commit-id ORIG_HEAD HEAD")
                    ];
                case 1:
                    stdout = _state.sent().stdout;
                    if (!stdout.match("package.json")) return [
                        3,
                        6
                    ];
                    _state.label = 2;
                case 2:
                    _state.trys.push([
                        2,
                        4,
                        ,
                        5
                    ]);
                    return [
                        4,
                        (0, import_detect_package_manager.detect)()
                    ];
                case 3:
                    pm = _state.sent();
                    install(pm);
                    return [
                        3,
                        5
                    ];
                case 4:
                    e = _state.sent();
                    console.warn("Could not detect package manager. Trying npm...");
                    install();
                    return [
                        3,
                        5
                    ];
                case 5:
                    return [
                        3,
                        7
                    ];
                case 6:
                    console.log((0, import_kolorist2.green)("✔ Nothing to update"));
                    _state.label = 7;
                case 7:
                    return [
                        2
                    ];
            }
        });
    });
    return function handler2() {
        return _ref.apply(this, arguments);
    };
}();
// src/cli.ts
var tools = yargs.scriptName("repo-tools").command(check_remote_exports).command(install_packages_exports).demandCommand(1).help().wrap(72).version(getVersion());
var cli_default = tools.strict().argv;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
    tools: tools
});
//# sourceMappingURL=cli.js.map