ya-git-jira 1.2.0 → 1.4.0

package/bin/git-lab.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import { isMain } from '../lib/is_main'
+
+import groups from './git-lab-group'
+import merges from './git-lab-merge'
+import namespaces from './git-lab-namespace'
+import projects from './git-lab-project'
+import whoami from './git-lab-whoami'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('lab')
+        .description('Commands for working with GitLab')
+        .addCommand(groups())
+        .addCommand(merges())
+        .addCommand(namespaces())
+        .addCommand(projects())
+        .addCommand(whoami())
+        .action(() => program.help())
+    return program
+}
+
+export default create
+
+if (isMain('git-lab')) {
+    await create().parseAsync(Bun.argv)
+}

package/bin/gitj.ts

@@ -1,24 +1,27 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 
-// This is the root of the CLI. It's job is to parse the command
+import bump from './git-bump'
+import jira from './git-jira'
+import lab from './git-lab'
+
+// This is the root of the CLI. It's a proxy for git and not strictly
+// necessary, but it's useful to have for testing
+// It's job is to parse the first command
 // from the command line and then call the appropriate subcommand.
 
 import { Command } from 'commander'
-import { isMain } from '../lib/is_main'
-
-if (isMain('gitj')) {
-
-    const program = new Command()
-    const bump = (await import('./git-bump')).create()
-
-    program
-        .executableDir('./bin')
-        .addCommand(bump)
-        .command('jira', 'A collection of jira utility commands', { executableFile: 'git-jira' })
 
+export function create(): Command {
+    const program: Command = new Command()
     program
+        .addCommand(bump())
+        .addCommand(jira())
+        .addCommand(lab())
         .action(() => {
             program.help()
         })
-        .parse(Bun.argv)
+    return program
 }
+
+const command = create()
+await command.parseAsync(Bun.argv)

package/build.ts

@@ -0,0 +1,17 @@
+import { BuildOutput } from 'bun'
+import { glob } from 'glob'
+
+const result: BuildOutput = await Bun.build({
+    entrypoints: ['./index.ts', ...glob.sync('./bin/*.ts')],
+    outdir: './dist',
+    target: 'bun',
+})
+
+if (result.success) {
+    console.log('Build succeeded')
+    process.exit(0)
+} else {
+    console.error('Build failed')
+    console.log(result)
+    process.exit(1)
+}

package/dist/bin/git-bump.js

@@ -20,50 +20,6 @@ var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports,
 var __require = (id) => {
   return import.meta.require(id);
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-
-// lib/spawn.ts
-async function doCommand(args) {
-  const proc = Bun.spawn(args);
-  const stdout = new Response(proc.stdout);
-  const stderr = new Response(proc.stderr);
-  const [out, err] = await Promise.all([stdout.text(), stderr.text()]);
-  if (err)
-    console.error(err);
-  return out.trim();
-}
-var init_spawn = __esm(() => {
-});
-
-// lib/git.ts
-async function getConfig(key) {
-  return doCommand(["git", "config", "--get", key]);
-}
-async function getJiraConfig() {
-  const host = await getConfig("jira.host");
-  const user = await getConfig("jira.user") || await getConfig("user.email");
-  const pat = await getConfig("jira.pat");
-  const token = Buffer.from(`${user}:${pat}`).toString("base64");
-  return { host, token };
-}
-async function createBranch(name) {
-  return doCommand(["git", "checkout", "-b", name]);
-}
-async function getCurrentBranch() {
-  return doCommand(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
-}
-var init_git = __esm(() => {
-  init_spawn();
-});
 
 // node_modules/commander/lib/error.js
 var require_error = __commonJS((exports) => {
@@ -680,7 +636,7 @@ var require_command = __commonJS((exports) => {
   var childProcess = import.meta.require("child_process");
   var path = import.meta.require("path");
   var fs = import.meta.require("fs");
-  var process2 = import.meta.require("process");
+  var process = import.meta.require("process");
   var { Argument, humanReadableArgName } = require_argument();
   var { CommanderError } = require_error();
   var { Help } = require_help();
@@ -721,10 +677,10 @@ var require_command = __commonJS((exports) => {
       this._showHelpAfterError = false;
       this._showSuggestionAfterError = true;
       this._outputConfiguration = {
-        writeOut: (str) => process2.stdout.write(str),
-        writeErr: (str) => process2.stderr.write(str),
-        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
-        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
+        writeOut: (str) => process.stdout.write(str),
+        writeErr: (str) => process.stderr.write(str),
+        getOutHelpWidth: () => process.stdout.isTTY ? process.stdout.columns : undefined,
+        getErrHelpWidth: () => process.stderr.isTTY ? process.stderr.columns : undefined,
         outputError: (str, write) => write(str)
       };
       this._hidden = false;
@@ -907,7 +863,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (this._exitCallback) {
         this._exitCallback(new CommanderError(exitCode, code, message));
       }
-      process2.exit(exitCode);
+      process.exit(exitCode);
     }
     action(fn) {
       const listener = (args) => {
@@ -1072,8 +1028,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       parseOptions = parseOptions || {};
       if (argv === undefined) {
-        argv = process2.argv;
-        if (process2.versions && process2.versions.electron) {
+        argv = process.argv;
+        if (process.versions && process.versions.electron) {
           parseOptions.from = "electron";
         }
       }
@@ -1086,7 +1042,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           userArgs = argv.slice(2);
           break;
         case "electron":
-          if (process2.defaultApp) {
+          if (process.defaultApp) {
             this._scriptPath = argv[1];
             userArgs = argv.slice(2);
           } else {
@@ -1154,23 +1110,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       launchWithNode = sourceExt.includes(path.extname(executableFile));
       let proc;
-      if (process2.platform !== "win32") {
+      if (process.platform !== "win32") {
         if (launchWithNode) {
           args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
+          args = incrementNodeInspectorPort(process.execArgv).concat(args);
+          proc = childProcess.spawn(process.argv[0], args, { stdio: "inherit" });
         } else {
           proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
         }
       } else {
         args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
+        args = incrementNodeInspectorPort(process.execArgv).concat(args);
+        proc = childProcess.spawn(process.execPath, args, { stdio: "inherit" });
       }
       if (!proc.killed) {
         const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
         signals.forEach((signal) => {
-          process2.on(signal, () => {
+          process.on(signal, () => {
             if (proc.killed === false && proc.exitCode === null) {
               proc.kill(signal);
             }
@@ -1179,10 +1135,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       const exitCallback = this._exitCallback;
       if (!exitCallback) {
-        proc.on("close", process2.exit.bind(process2));
+        proc.on("close", process.exit.bind(process));
       } else {
         proc.on("close", () => {
-          exitCallback(new CommanderError(process2.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
+          exitCallback(new CommanderError(process.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
         });
       }
       proc.on("error", (err) => {
@@ -1197,7 +1153,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           throw new Error(`'${executableFile}' not executable`);
         }
         if (!exitCallback) {
-          process2.exit(1);
+          process.exit(1);
         } else {
           const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
           wrappedError.nestedError = err;
@@ -1549,11 +1505,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     _parseOptionsEnv() {
       this.options.forEach((option) => {
-        if (option.envVar && (option.envVar in process2.env)) {
+        if (option.envVar && (option.envVar in process.env)) {
           const optionKey = option.attributeName();
           if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
             if (option.required || option.optional) {
-              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
+              this.emit(`optionEnv:${option.name()}`, process.env[option.envVar]);
             } else {
               this.emit(`optionEnv:${option.name()}`);
             }
@@ -1779,7 +1735,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = process2.exitCode || 0;
+      let exitCode = process.exitCode || 0;
       if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
         exitCode = 1;
       }
@@ -1827,24 +1783,60 @@ var require_commander = __commonJS((exports, module) => {
   exports.Option = Option;
 });
 
+// lib/spawn.ts
+async function spawn(args, options = defaultOptions) {
+  const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
+  const stdout = new Response(proc.stdout);
+  const stderr = new Response(proc.stderr);
+  const [out, err, exitCode, signal] = await Promise.all([stdout.text(), stderr.text(), proc.exitCode, proc.signalCode]);
+  let code = 0;
+  if (exitCode !== null) {
+    code = exitCode;
+  }
+  if (!out && !err && !options.expectQuiet) {
+    console.warn(`No output from ${args.join(" ")}`);
+  }
+  return { out: out.trim(), err: err.trim(), code };
+}
+async function doCommand(args) {
+  const { out, err } = await spawn(args);
+  if (err)
+    console.error(err);
+  return out;
+}
+var defaultOptions = {
+  expectQuiet: false
+};
+
+// lib/git.ts
+async function getConfig(key) {
+  return doCommand(["git", "config", "--get", key]);
+}
+async function createBranch(name) {
+  return doCommand(["git", "checkout", "-b", name]);
+}
+async function getCurrentBranch() {
+  return doCommand(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
+}
+async function getRemote() {
+  return doCommand(["git", "ls-remote", "--get-url", "origin"]);
+}
+
 // node_modules/commander/esm.mjs
-var import_, program, createCommand, createArgument, createOption, CommanderError, InvalidArgumentError, InvalidOptionArgumentError, Command, Argument, Option, Help;
-var init_esm = __esm(() => {
-  import_ = __toESM(require_commander(), 1);
-  ({
-    program,
-    createCommand,
-    createArgument,
-    createOption,
-    CommanderError,
-    InvalidArgumentError,
-    InvalidOptionArgumentError,
-    Command,
-    Argument,
-    Option,
-    Help
-  } = import_.default);
-});
+var import_ = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  Command,
+  Argument,
+  Option,
+  Help
+} = import_.default;
 
 // lib/is_main.ts
 import path from "path";
@@ -1852,26 +1844,11 @@ function isMain(self) {
   const exe = path.basename(Bun.argv[1]).split(".")[0];
   return exe == self || import.meta.main;
 }
-var init_is_main = __esm(() => {
-});
 
 // bin/git-bump.ts
-var exports_git_bump = {};
-__export(exports_git_bump, {
-  default: () => {
-    {
-      return git_bump_default;
-    }
-  },
-  create: () => {
-    {
-      return create;
-    }
-  }
-});
 function create() {
   const program2 = new Command;
-  program2.name("bump").action(async () => {
+  program2.name("bump").description("Bump the version number in the current branch").action(async () => {
     const currentBranch = await getCurrentBranch();
     let stem = currentBranch;
     let version = 1;
@@ -1885,18 +1862,10 @@ function create() {
   });
   return program2;
 }
-var git_bump_default;
-var init_git_bump = __esm(() => {
-  init_git();
-  init_esm();
-  init_is_main();
-  if (isMain("git-bump")) {
-    create().parse(process.argv);
-  }
-  git_bump_default = create;
-});
-init_git_bump();
-
+if (isMain("git-bump")) {
+  await create().parseAsync(Bun.argv);
+}
+var git_bump_default = create;
 export {
   git_bump_default as default,
   create

package/dist/bin/git-jira-issue.js

@@ -20,16 +20,6 @@ var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports,
 var __require = (id) => {
   return import.meta.require(id);
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // node_modules/commander/lib/error.js
 var require_error = __commonJS((exports) => {
@@ -1794,59 +1784,74 @@ var require_commander = __commonJS((exports, module) => {
 });
 
 // node_modules/commander/esm.mjs
-var import_, program, createCommand, createArgument, createOption, CommanderError, InvalidArgumentError, InvalidOptionArgumentError, Command, Argument, Option, Help;
-var init_esm = __esm(() => {
-  import_ = __toESM(require_commander(), 1);
-  ({
-    program,
-    createCommand,
-    createArgument,
-    createOption,
-    CommanderError,
-    InvalidArgumentError,
-    InvalidOptionArgumentError,
-    Command,
-    Argument,
-    Option,
-    Help
-  } = import_.default);
-});
+var import_ = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  Command,
+  Argument,
+  Option,
+  Help
+} = import_.default;
 
 // lib/spawn.ts
-async function doCommand(args) {
-  const proc = Bun.spawn(args);
+async function spawn(args, options = defaultOptions) {
+  const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
   const stdout = new Response(proc.stdout);
   const stderr = new Response(proc.stderr);
-  const [out, err] = await Promise.all([stdout.text(), stderr.text()]);
+  const [out, err, exitCode, signal] = await Promise.all([stdout.text(), stderr.text(), proc.exitCode, proc.signalCode]);
+  let code = 0;
+  if (exitCode !== null) {
+    code = exitCode;
+  }
+  if (!out && !err && !options.expectQuiet) {
+    console.warn(`No output from ${args.join(" ")}`);
+  }
+  return { out: out.trim(), err: err.trim(), code };
+}
+async function doCommand(args) {
+  const { out, err } = await spawn(args);
   if (err)
     console.error(err);
-  return out.trim();
+  return out;
 }
-var init_spawn = __esm(() => {
-});
+var defaultOptions = {
+  expectQuiet: false
+};
 
 // lib/git.ts
 async function getConfig(key) {
   return doCommand(["git", "config", "--get", key]);
 }
-async function getJiraConfig() {
-  const host = await getConfig("jira.host");
-  const user = await getConfig("jira.user") || await getConfig("user.email");
-  const pat = await getConfig("jira.pat");
-  const token = Buffer.from(`${user}:${pat}`).toString("base64");
-  return { host, token };
-}
 async function createBranch(name) {
   return doCommand(["git", "checkout", "-b", name]);
 }
 async function getCurrentBranch() {
   return doCommand(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
 }
-var init_git = __esm(() => {
-  init_spawn();
-});
+async function getRemote() {
+  return doCommand(["git", "ls-remote", "--get-url", "origin"]);
+}
 
 // lib/jira.ts
+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)
+    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");
+  return { host, token };
+}
 async function get(endpoint) {
   const method = "GET";
   const { host, token } = await getJiraConfig();
@@ -1877,9 +1882,6 @@ async function myUnresolvedIssues() {
   const issues = await get(`/search?jql=${encodeURIComponent(jql)}`);
   return issues.issues;
 }
-var init_jira = __esm(() => {
-  init_git();
-});
 
 // lib/is_main.ts
 import path from "path";
@@ -1887,26 +1889,12 @@ function isMain(self) {
   const exe = path.basename(Bun.argv[1]).split(".")[0];
   return exe == self || import.meta.main;
 }
-var init_is_main = __esm(() => {
-});
 
 // bin/git-jira-issue.ts
-var exports_git_jira_issue = {};
-__export(exports_git_jira_issue, {
-  default: () => {
-    {
-      return git_jira_issue_default;
-    }
-  },
-  create: () => {
-    {
-      return create;
-    }
-  }
-});
 function create() {
   const program2 = new Command;
-  program2.name("issue").argument("issue", "Issue ID").option("-v, --verbose", "Verbose output").option("-u, --url", "Show the URL of the issue").action(async (issueId, options) => {
+  program2.name("issue").description("Get information about an issue").argument("issue", "Issue ID").option("-v, --verbose", "Verbose output").option("-u, --url", "Show the URL of the issue").action(async (issueId, options) => {
+    const { host } = await getJiraConfig();
     const issue = await getIssue(issueId);
     if (!issue) {
       console.error(`Issue ${issueId} not found`);
@@ -1917,23 +1905,15 @@ function create() {
       process.exit(0);
     }
     if (options.url) {
-      console.log(issue.self);
+      console.log(`https://${host}/browse/${issueId}`);
     }
   });
   return program2;
 }
-var git_jira_issue_default;
-var init_git_jira_issue = __esm(() => {
-  init_esm();
-  init_jira();
-  init_is_main();
-  if (isMain("git-jira-issue")) {
-    create().parse(process.argv);
-  }
-  git_jira_issue_default = create;
-});
-init_git_jira_issue();
-
+if (isMain("git-jira-issue")) {
+  await create().parseAsync(Bun.argv);
+}
+var git_jira_issue_default = create;
 export {
   git_jira_issue_default as default,
   create