ya-git-jira 1.3.0 → 1.5.0

package/dist/index.js

@@ -19,7 +19,728 @@ var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports,
 var __require = (id) => {
   return import.meta.require(id);
 };
-// lib/spawn.ts
+
+// bine_modules/commander/l
+var require_ms = __commonJS((exports, module) => {
+  var parse = function(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+    if (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return;
+    }
+  };
+  var fmtShort = function(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return Math.round(ms / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms / h) + "h";
+    }
+    if (msAbs >= m) {
+      return Math.round(ms / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms / s) + "s";
+    }
+    return ms + "ms";
+  };
+  var fmtLong = function(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return plural(ms, msAbs, d, "day");
+    }
+    if (msAbs >= h) {
+      return plural(ms, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms, msAbs, s, "second");
+    }
+    return ms + " ms";
+  };
+  var plural = function(ms, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+  };
+  var s = 1000;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+  module.exports = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
+  };
+});
+
+// bine_modules/commander/lib/sugge
+var require_common = __commonJS((exports, module) => {
+  var setup = function(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = require_ms();
+    createDebug.destroy = destroy;
+    Object.keys(env).forEach((key) => {
+      createDebug[key] = env[key];
+    });
+    createDebug.names = [];
+    createDebug.skips = [];
+    createDebug.formatters = {};
+    function selectColor(namespace) {
+      let hash = 0;
+      for (let i = 0;i < namespace.length; i++) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      let prevTime;
+      let enableOverride = null;
+      let namespacesCache;
+      let enabledCache;
+      function debug(...args) {
+        if (!debug.enabled) {
+          return;
+        }
+        const self = debug;
+        const curr = Number(new Date);
+        const ms = curr - (prevTime || curr);
+        self.diff = ms;
+        self.prev = prevTime;
+        self.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug.coerce(args[0]);
+        if (typeof args[0] !== "string") {
+          args.unshift("%O");
+        }
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+          if (match === "%%") {
+            return "%";
+          }
+          index++;
+          const formatter = createDebug.formatters[format];
+          if (typeof formatter === "function") {
+            const val = args[index];
+            match = formatter.call(self, val);
+            args.splice(index, 1);
+            index--;
+          }
+          return match;
+        });
+        createDebug.formatArgs.call(self, args);
+        const logFn = self.log || createDebug.log;
+        logFn.apply(self, args);
+      }
+      debug.namespace = namespace;
+      debug.useColors = createDebug.useColors();
+      debug.color = createDebug.selectColor(namespace);
+      debug.extend = extend;
+      debug.destroy = createDebug.destroy;
+      Object.defineProperty(debug, "enabled", {
+        enumerable: true,
+        configurable: false,
+        get: () => {
+          if (enableOverride !== null) {
+            return enableOverride;
+          }
+          if (namespacesCache !== createDebug.namespaces) {
+            namespacesCache = createDebug.namespaces;
+            enabledCache = createDebug.enabled(namespace);
+          }
+          return enabledCache;
+        },
+        set: (v) => {
+          enableOverride = v;
+        }
+      });
+      if (typeof createDebug.init === "function") {
+        createDebug.init(debug);
+      }
+      return debug;
+    }
+    function extend(namespace, delimiter) {
+      const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+      newDebug.log = this.log;
+      return newDebug;
+    }
+    function enable(namespaces) {
+      createDebug.save(namespaces);
+      createDebug.namespaces = namespaces;
+      createDebug.names = [];
+      createDebug.skips = [];
+      let i;
+      const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+      const len = split.length;
+      for (i = 0;i < len; i++) {
+        if (!split[i]) {
+          continue;
+        }
+        namespaces = split[i].replace(/\*/g, ".*?");
+        if (namespaces[0] === "-") {
+          createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
+        } else {
+          createDebug.names.push(new RegExp("^" + namespaces + "$"));
+        }
+      }
+    }
+    function disable() {
+      const namespaces = [
+        ...createDebug.names.map(toNamespace),
+        ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
+      ].join(",");
+      createDebug.enable("");
+      return namespaces;
+    }
+    function enabled(name) {
+      if (name[name.length - 1] === "*") {
+        return true;
+      }
+      let i;
+      let len;
+      for (i = 0, len = createDebug.skips.length;i < len; i++) {
+        if (createDebug.skips[i].test(name)) {
+          return false;
+        }
+      }
+      for (i = 0, len = createDebug.names.length;i < len; i++) {
+        if (createDebug.names[i].test(name)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function toNamespace(regexp) {
+      return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
+    }
+    function coerce(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
+    }
+    function destroy() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    createDebug.enable(createDebug.load());
+    return createDebug;
+  };
+  module.exports = setup;
+});
+
+// bine_modules/commander/lib/sugges
+var require_browser = __commonJS((exports, module) => {
+  var useColors = function() {
+    if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+      return true;
+    }
+    if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+      return false;
+    }
+    return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+  };
+  var formatArgs = function(args) {
+    args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + exports.humanize(this.diff);
+    if (!this.useColors) {
+      return;
+    }
+    const c = "color: " + this.color;
+    args.splice(1, 0, c, "color: inherit");
+    let index = 0;
+    let lastC = 0;
+    args[0].replace(/%[a-zA-Z%]/g, (match) => {
+      if (match === "%%") {
+        return;
+      }
+      index++;
+      if (match === "%c") {
+        lastC = index;
+      }
+    });
+    args.splice(lastC, 0, c);
+  };
+  var save = function(namespaces) {
+    try {
+      if (namespaces) {
+        exports.storage.setItem("debug", namespaces);
+      } else {
+        exports.storage.removeItem("debug");
+      }
+    } catch (error) {
+    }
+  };
+  var load = function() {
+    let r;
+    try {
+      r = exports.storage.getItem("debug");
+    } catch (error) {
+    }
+    if (!r && typeof process !== "undefined" && ("env" in process)) {
+      r = process.env.DEBUG;
+    }
+    return r;
+  };
+  var localstorage = function() {
+    try {
+      return localStorage;
+    } catch (error) {
+    }
+  };
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.storage = localstorage();
+  exports.destroy = (() => {
+    let warned = false;
+    return () => {
+      if (!warned) {
+        warned = true;
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+    };
+  })();
+  exports.colors = [
+    "#0000CC",
+    "#0000FF",
+    "#0033CC",
+    "#0033FF",
+    "#0066CC",
+    "#0066FF",
+    "#0099CC",
+    "#0099FF",
+    "#00CC00",
+    "#00CC33",
+    "#00CC66",
+    "#00CC99",
+    "#00CCCC",
+    "#00CCFF",
+    "#3300CC",
+    "#3300FF",
+    "#3333CC",
+    "#3333FF",
+    "#3366CC",
+    "#3366FF",
+    "#3399CC",
+    "#3399FF",
+    "#33CC00",
+    "#33CC33",
+    "#33CC66",
+    "#33CC99",
+    "#33CCCC",
+    "#33CCFF",
+    "#6600CC",
+    "#6600FF",
+    "#6633CC",
+    "#6633FF",
+    "#66CC00",
+    "#66CC33",
+    "#9900CC",
+    "#9900FF",
+    "#9933CC",
+    "#9933FF",
+    "#99CC00",
+    "#99CC33",
+    "#CC0000",
+    "#CC0033",
+    "#CC0066",
+    "#CC0099",
+    "#CC00CC",
+    "#CC00FF",
+    "#CC3300",
+    "#CC3333",
+    "#CC3366",
+    "#CC3399",
+    "#CC33CC",
+    "#CC33FF",
+    "#CC6600",
+    "#CC6633",
+    "#CC9900",
+    "#CC9933",
+    "#CCCC00",
+    "#CCCC33",
+    "#FF0000",
+    "#FF0033",
+    "#FF0066",
+    "#FF0099",
+    "#FF00CC",
+    "#FF00FF",
+    "#FF3300",
+    "#FF3333",
+    "#FF3366",
+    "#FF3399",
+    "#FF33CC",
+    "#FF33FF",
+    "#FF6600",
+    "#FF6633",
+    "#FF9900",
+    "#FF9933",
+    "#FFCC00",
+    "#FFCC33"
+  ];
+  exports.log = console.debug || console.log || (() => {
+  });
+  module.exports = require_common()(exports);
+  var { formatters } = module.exports;
+  formatters.j = function(v) {
+    try {
+      return JSON.stringify(v);
+    } catch (error) {
+      return "[UnexpectedJSONParseError]: " + error.message;
+    }
+  };
+});
+
+// /home/jim/node_modules/has-flag/index.js
+var require_has_flag = __commonJS((exports, module) => {
+  module.exports = (flag, argv = process.argv) => {
+    const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf("--");
+    return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+  };
+});
+
+// /home/jim/node_modules/supports-color/index.js
+var require_supports_color = __commonJS((exports, module) => {
+  var translateLevel = function(level) {
+    if (level === 0) {
+      return false;
+    }
+    return {
+      level,
+      hasBasic: true,
+      has256: level >= 2,
+      has16m: level >= 3
+    };
+  };
+  var supportsColor = function(haveStream, streamIsTTY) {
+    if (forceColor === 0) {
+      return 0;
+    }
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+    if (haveStream && !streamIsTTY && forceColor === undefined) {
+      return 0;
+    }
+    const min = forceColor || 0;
+    if (env.TERM === "dumb") {
+      return min;
+    }
+    if (process.platform === "win32") {
+      const osRelease = os.release().split(".");
+      if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+        return Number(osRelease[2]) >= 14931 ? 3 : 2;
+      }
+      return 1;
+    }
+    if ("CI" in env) {
+      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+        return 1;
+      }
+      return min;
+    }
+    if ("TEAMCITY_VERSION" in env) {
+      return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    }
+    if (env.COLORTERM === "truecolor") {
+      return 3;
+    }
+    if ("TERM_PROGRAM" in env) {
+      const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+      switch (env.TERM_PROGRAM) {
+        case "iTerm.app":
+          return version >= 3 ? 3 : 2;
+        case "Apple_Terminal":
+          return 2;
+      }
+    }
+    if (/-256(color)?$/i.test(env.TERM)) {
+      return 2;
+    }
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+      return 1;
+    }
+    if ("COLORTERM" in env) {
+      return 1;
+    }
+    return min;
+  };
+  var getSupportLevel = function(stream) {
+    const level = supportsColor(stream, stream && stream.isTTY);
+    return translateLevel(level);
+  };
+  var os = import.meta.require("os");
+  var tty = import.meta.require("tty");
+  var hasFlag = require_has_flag();
+  var { env } = process;
+  var forceColor;
+  if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+    forceColor = 0;
+  } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+    forceColor = 1;
+  }
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      forceColor = 1;
+    } else if (env.FORCE_COLOR === "false") {
+      forceColor = 0;
+    } else {
+      forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+    }
+  }
+  module.exports = {
+    supportsColor: getSupportLevel,
+    stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+    stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+  };
+});
+
+// bine_modules/commander/lib/sug
+var require_node = __commonJS((exports, module) => {
+  var useColors = function() {
+    return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+  };
+  var formatArgs = function(args) {
+    const { namespace: name, useColors: useColors2 } = this;
+    if (useColors2) {
+      const c = this.color;
+      const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+      const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+      args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+      args.push(colorCode + "m+" + exports.humanize(this.diff) + "\x1B[0m");
+    } else {
+      args[0] = getDate() + name + " " + args[0];
+    }
+  };
+  var getDate = function() {
+    if (exports.inspectOpts.hideDate) {
+      return "";
+    }
+    return new Date().toISOString() + " ";
+  };
+  var log = function(...args) {
+    return process.stderr.write(util.format(...args) + "\n");
+  };
+  var save = function(namespaces) {
+    if (namespaces) {
+      process.env.DEBUG = namespaces;
+    } else {
+      delete process.env.DEBUG;
+    }
+  };
+  var load = function() {
+    return process.env.DEBUG;
+  };
+  var init = function(debug) {
+    debug.inspectOpts = {};
+    const keys = Object.keys(exports.inspectOpts);
+    for (let i = 0;i < keys.length; i++) {
+      debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+    }
+  };
+  var tty = import.meta.require("tty");
+  var util = import.meta.require("util");
+  exports.init = init;
+  exports.log = log;
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.destroy = util.deprecate(() => {
+  }, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+  exports.colors = [6, 2, 3, 4, 5, 1];
+  try {
+    const supportsColor = require_supports_color();
+    if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+      exports.colors = [
+        20,
+        21,
+        26,
+        27,
+        32,
+        33,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        56,
+        57,
+        62,
+        63,
+        68,
+        69,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        92,
+        93,
+        98,
+        99,
+        112,
+        113,
+        128,
+        129,
+        134,
+        135,
+        148,
+        149,
+        160,
+        161,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        171,
+        172,
+        173,
+        178,
+        179,
+        184,
+        185,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        203,
+        204,
+        205,
+        206,
+        207,
+        208,
+        209,
+        214,
+        215,
+        220,
+        221
+      ];
+    }
+  } catch (error) {
+  }
+  exports.inspectOpts = Object.keys(process.env).filter((key) => {
+    return /^debug_/i.test(key);
+  }).reduce((obj, key) => {
+    const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+      return k.toUpperCase();
+    });
+    let val = process.env[key];
+    if (/^(yes|on|true|enabled)$/i.test(val)) {
+      val = true;
+    } else if (/^(no|off|false|disabled)$/i.test(val)) {
+      val = false;
+    } else if (val === "null") {
+      val = null;
+    } else {
+      val = Number(val);
+    }
+    obj[prop] = val;
+    return obj;
+  }, {});
+  module.exports = require_common()(exports);
+  var { formatters } = module.exports;
+  formatters.o = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+  };
+  formatters.O = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts);
+  };
+});
+
+// bine_modules/commander/lib/sugg
+var require_src = __commonJS((exports, module) => {
+  if (typeof process === "undefined" || process.type === "renderer" || false || process.__nwjs) {
+    module.exports = require_browser();
+  } else {
+    module.exports = require_node();
+  }
+});
+// bine_modules
 async function spawn(args, options = defaultOptions) {
   const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
   const stdout = new Response(proc.stdout);
@@ -44,7 +765,7 @@ var defaultOptions = {
   expectQuiet: false
 };
 
-// lib/git.ts
+// bine_modul
 async function getConfig(key) {
   return doCommand(["git", "config", "--get", key]);
 }
@@ -57,25 +778,44 @@ async function getCurrentBranch() {
 async function getRemote() {
   return doCommand(["git", "ls-remote", "--get-url", "origin"]);
 }
-// lib/gitlab.ts
-import path from "path";
+// bine_modules/command
 async function getGitlabConfig() {
-  const host = await getConfig("gitlab.host");
+  const host = await hostP;
   if (!host)
     throw new Error("gitlab.host not in git config");
-  const user = await getConfig("user.email");
+  const user = await userP;
   if (!user)
     throw new Error("user.email not in git config");
-  const token = await getConfig("gitlab.token");
+  const token = await tokenP;
   if (!token)
     throw new Error("gitlab.token not in git config");
   return { host, user, token };
 }
-async function get(endpoint) {
+var hostP = getConfig("gitlab.host");
+var userP = getConfig("user.email");
+var tokenP = getConfig("gitlab.token");
+
+// bine_modules/comm
+var getNextLink = function(link) {
+  if (!link) {
+    return;
+  }
+  const regex = /<([^>]+)>; rel="next"/;
+  const match = link.match(regex);
+  const next = match ? match[1] : undefined;
+  return next;
+};
+async function gitlabApi(endpoint) {
+  if (endpoint.startsWith("/")) {
+    console.warn(`gitlabApi: endpoint ${endpoint} starts with /, removing it`);
+    endpoint = endpoint.slice(1);
+  }
   const method = "GET";
   const { host, token } = await getGitlabConfig();
   const base = `https://${host}/api/v4`;
-  const uri = `${base}/${endpoint}`;
+  const requested = 100;
+  const sep = endpoint.includes("?") ? "&" : "?";
+  const uri = `${base}/${endpoint}${sep}per_page=${requested}`;
   const headers = new Headers;
   headers.append("Accept", "application/json");
   headers.append("Private-Token", token);
@@ -83,19 +823,50 @@ async function get(endpoint) {
     method,
     headers
   };
-  const request = new Request(uri, options);
+  let request = new Request(uri, options);
   const response = await fetch(request);
-  return await response.json();
+  let link = getNextLink(response.headers.get("Link"));
+  let partial = await response.json();
+  let result = partial;
+  while (partial.length == requested && link) {
+    let request2 = new Request(link, options);
+    const next_response = await fetch(request2);
+    link = getNextLink(next_response.headers.get("Link"));
+    partial = await next_response.json();
+    result = result.concat(partial);
+  }
+  return result;
 }
-async function whoami() {
-  return await get("/user");
+// bine_modules/comman
+async function getGroups() {
+  return await gitlabApi(`groups`);
 }
-async function getProjects(paths) {
+// bine_modules/commande
+import path from "path";
+
+// bine_modules/comma
+var import_debug = __toESM(require_src(), 1);
+var dlog = import_debug.default("gitlab");
+
+// bine_modules/commande
+async function getProjects(match) {
   let search = "";
-  if (paths.length > 0) {
-    search = "&search=" + paths.join(",");
+  if (match) {
+    const m = encodeURIComponent(match);
+    search = `&search=${m}`;
+  }
+  const projects = await gitlabApi(`projects?membership=true&simple=true${search}`);
+  if (!projects) {
+    throw new Error(`No projects!`);
+  } else if (!Array.isArray(projects)) {
+    console.log(projects);
+    throw new Error(`Projects is not an array!`);
   }
-  return await get(`/projects?visibility=private&membership=true&simple=true${search}`);
+  const projs = projects;
+  const filtered = projs.filter((p) => {
+    return p.path_with_namespace.toLowerCase().includes(match.toLowerCase());
+  });
+  return filtered;
 }
 async function findProject(ssh_url) {
   const parts = ssh_url.split(":");
@@ -103,43 +874,108 @@ async function findProject(ssh_url) {
     throw new Error(`${ssh_url} is invalid, could not be split into two parts at :`);
   }
   const name = path.basename(parts[1], ".git");
-  const projects = await getProjects([name]);
+  const projects = await getProjects(name);
   const project = projects.find((p) => {
     return p.ssh_url_to_repo === ssh_url;
   });
+  return project;
+}
+async function projectScopedGet(endpoint) {
+  if (endpoint.startsWith("/")) {
+    console.warn(`gitlabApi: endpoint ${endpoint} starts with /, removing it`);
+    endpoint = endpoint.slice(1);
+  }
+  const method = "GET";
+  const { host, token } = await getGitlabConfig();
+  const remote = await getRemote();
+  const project = await findProject(remote);
   if (!project) {
-    throw new Error(`No project with ssh_url_to_repo ${ssh_url} found`);
+    throw new Error(`Could not find project for remote ${remote}`);
   }
-  return project;
+  const base = `https://${host}/api/v4/projects/${project.id}`;
+  const uri = `${base}/${endpoint}`;
+  dlog(`projectScopedGet uri: ${uri}`);
+  const headers = new Headers;
+  headers.append("Accept", "application/json");
+  headers.append("Private-Token", token);
+  const options = {
+    method,
+    headers
+  };
+  const request = new Request(uri, options);
+  const response = await fetch(request);
+  return await response.json();
+}
+
+// bine_modules/comma
+async function whoami() {
+  return await gitlabApi("user");
 }
+
+// bine_modules/commander/lib/
 async function getMergeRequest(id) {
-  return await get(`/merge_requests/${id}`);
+  return await projectScopedGet(`merge_requests/${id}`);
+}
+async function getMyMergeRequestsInProgress() {
+  const me = await whoami();
+  return await gitlabApi(`merge_requests?state=opened&author_id=${me.id}`);
+}
+async function getMyMergeRequestsToReview() {
+  const me = await whoami();
+  return await gitlabApi(`merge_requests?state=opened&reviewer_id=${me.id}`);
+}
+// bine_modules/commander/
+async function getNamespaces() {
+  return await gitlabApi(`namespaces`);
+}
+// bine_modules/commander
+async function getProjectPipelines(options) {
+  const { days, status } = options;
+  const me = await whoami();
+  const username = me.username;
+  const date = new Date;
+  const pastDate = date.getDate() - days;
+  date.setDate(pastDate);
+  const updated = date.toISOString();
+  dlog(`updated: ${updated}`);
+  return await projectScopedGet(`pipelines?status=${status}&username=${username}&updated_after=${updated}`);
 }
-// lib/is_main.ts
+// bine_modules/c
 import path2 from "path";
+var justBase = function(filename) {
+  const ext = path2.extname(filename);
+  const base = path2.basename(filename, ext);
+  return base;
+};
 function isMain(self) {
-  const exe = path2.basename(Bun.argv[1]).split(".")[0];
-  return exe == self || import.meta.main;
+  const arg1 = Bun.argv[1];
+  const argv1Base = justBase(arg1);
+  const selfBase = justBase(self);
+  const result = argv1Base === selfBase;
+  return result;
 }
-// lib/jira.ts
+// bine_module
 async function getJiraConfig() {
   const host = await getConfig("jira.host");
   if (!host)
     throw new Error("jira.host not in git config");
-  const user = await getConfig("jira.user") || await getConfig("user.email");
-  if (!user)
+  const user4 = await getConfig("jira.user") || await getConfig("user.email");
+  if (!user4)
     throw new Error("jira.user or user.email not in git config");
   const pat = await getConfig("jira.pat");
   if (!pat)
     throw new Error("jira.pat not in git config");
-  const token = Buffer.from(`${user}:${pat}`).toString("base64");
+  const token = Buffer.from(`${user4}:${pat}`).toString("base64");
   return { host, token };
 }
-async function get2(endpoint) {
+async function jiraApi(endpoint) {
+  if (endpoint.startsWith("/")) {
+    console.warn(`jiraApi: endpoint ${endpoint} starts with /`);
+    endpoint = endpoint.slice(1);
+  }
   const method = "GET";
   const { host, token } = await getJiraConfig();
-  const base = `https://${host}/rest/api/3`;
-  const uri = `${base}/${endpoint}`;
+  const uri = `https://${host}/rest/api/3/${endpoint}`;
   const auth = `Basic ${token}`;
   const headers = new Headers;
   headers.append("Authorization", auth);
@@ -150,32 +986,42 @@ async function get2(endpoint) {
   };
   const request = new Request(uri, options);
   const response = await fetch(request);
-  return await response.json();
+  const result = await response.json();
+  return result;
 }
 async function getIssue(issue) {
-  return await get2(`/issue/${issue}`);
+  const result = await jiraApi(`issue/${issue}`);
+  return result;
 }
 async function getMyself() {
-  return await get2("/myself");
+  return await jiraApi("/myself");
 }
 async function myUnresolvedIssues() {
   const myself = await getMyself();
   const myselfId = myself.accountId;
   const jql = `assignee = ${myselfId} AND resolution = Unresolved`;
-  const issues = await get2(`/search?jql=${encodeURIComponent(jql)}`);
+  const issues = await jiraApi(`/search?jql=${encodeURIComponent(jql)}`);
   return issues.issues;
 }
 export {
   whoami,
   spawn,
+  projectScopedGet,
   myUnresolvedIssues,
+  jiraApi,
   isMain,
+  gitlabApi,
   getRemote,
   getProjects,
+  getProjectPipelines,
+  getNamespaces,
   getMyself,
+  getMyMergeRequestsToReview,
+  getMyMergeRequestsInProgress,
   getMergeRequest,
   getJiraConfig,
   getIssue,
+  getGroups,
   getGitlabConfig,
   getCurrentBranch,
   getConfig,