ya-git-jira 1.2.0 → 1.3.0

package/README.md

@@ -1,13 +1,32 @@
 # ya-git-jira - Yet Another Git Jira
 
-This package installs two applications (for now) that are written to be
+This package installs several scripts that are written to be
 usable as `git` extensions, i.e. sub-commands of the `git` command.
 The extensions faciliate workflow when using `git` for source control and `jira`
 for issue tracking. Other similar packages exist -- thus the "yet another"
 in the name.
 
-This package will likely evolve over time to include some other workflow cases.
-For now, the two commands are:
+This package will likely evolve over time to include more workflow cases.
+
+## gitj -- A test driver to use instead of `git <command>`
+
+It can be useful to run these commands as if they were being invoked through
+`git` but using a proxy for `git` than can only execute the commands in this
+package.
+
+For example, to see the available top level commands, run `gitj --help`:
+
+```
+$ gitj ---help
+Usage: gitj [options] [command]
+
+Options:
+  -h, --help  display help for command
+
+Commands:
+  bump
+  jira        A collection of jira utility commands
+```
 
 ## git-jira-start -- Create a new topic branch for work on an issue
 

package/bin/git-bump.ts

@@ -8,6 +8,7 @@ export function create(): Command {
     const program = new Command()
     program
         .name('bump')
+        .description('Bump the version number in the current branch')
         .action(async () => {
             const currentBranch = await getCurrentBranch()
 
@@ -27,7 +28,7 @@ export function create(): Command {
 }
 
 if (isMain('git-bump')) {
-    create().parse(process.argv)
+    await create().parseAsync(Bun.argv)
 }
 
 export default create

package/bin/git-jira-issue.ts

@@ -3,15 +3,18 @@
 import { Command } from 'commander'
 import { getIssue } from "../lib/jira"
 import { isMain } from '../lib/is_main'
+import { getJiraConfig } from '../lib/jira'
 
-export function create() {
+export function create(): Command {
     const program = new Command()
     program
         .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: string, options) => {
+            const { host } = await getJiraConfig()
             const issue = await getIssue(issueId)
             if (!issue) {
                 console.error(`Issue ${issueId} not found`)
@@ -22,14 +25,14 @@ export function create() {
                 process.exit(0)
             }
             if (options.url) {
-                console.log(issue.self)
+                console.log(`https://${host}/browse/${issueId}`)
             }
         })
     return program
 }
 
 if (isMain('git-jira-issue')) {
-    create().parse(process.argv)
+    await create().parseAsync(Bun.argv)
 }
 
 export default create

package/bin/git-jira-issues.ts

@@ -8,6 +8,7 @@ export function create(): Command {
     const program = new Command()
     program
         .name('issues')
+        .description('List your unresolved issues')
         .action(async (options) => {
             const issues = await myUnresolvedIssues()
             console.log(`You have ${issues.length} unresolved issues`)
@@ -19,7 +20,7 @@ export function create(): Command {
 }
 
 if (isMain('git-jira-issues')) {
-    create().parse(process.argv)
+    await create().parseAsync(Bun.argv)
 }
 
 export default create

package/bin/git-jira-start.ts

@@ -15,6 +15,7 @@ export function create(): Command {
     const program = new Command()
     program
         .name('start')
+        .description('Start working on an issue by creating a branch')
         .argument('issue', 'Issue ID')
         .action(async (issueId: string) => {
             const issue = await getIssue(issueId)
@@ -32,7 +33,7 @@ export function create(): Command {
 }
 
 if (isMain('git-jira-issues')) {
-    create().parse(process.argv)
+    await create().parseAsync(Bun.argv)
 }
 
 export default create

package/bin/git-jira.ts

@@ -2,26 +2,23 @@
 
 import { Command } from 'commander'
 import { isMain } from '../lib/is_main'
+import start from './git-jira-start'
+import issue from './git-jira-issue'
+import issues from './git-jira-issues'
 
-const start = (await import('./git-jira-start')).create()
-const issue = (await import('./git-jira-issue')).create()
-const issues = (await import('./git-jira-issues')).create()
-
-export function create() {
+export function create(): Command {
     const program = new Command()
     program
         .name('jira')
-        .addCommand(start)
-        .addCommand(issue)
-        .addCommand(issues)
-        .action(() => {
-            program.help()
-        })
+        .description('A set of commands for working with Jira')
+        .addCommand(start())
+        .addCommand(issue())
+        .addCommand(issues())
     return program
 }
 
 if (isMain('git-jira')) {
-    create().parse(process.argv)
+    await create().parseAsync(Bun.argv)
 }
 
 export default create

package/bin/git-lab-projects.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env bun run
+
+import { Command } from 'commander'
+import { getProjects, type Project } from "../lib/gitlab"
+import { isMain } from '../lib/is_main'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('projects')
+        .description('List projects for current user')
+        .option('-v, --verbose', 'Verbose output')
+        .argument('[path...]', 'Namespace paths to filter by')
+        .action(async (paths: string[], options) => {
+            const projects: Array<Project> = await getProjects(paths)
+            if (!projects) {
+                console.error(`No projects!`)
+                process.exit(1)
+            }
+            if (options.verbose) {
+                console.log(projects)
+            }
+            else {
+                let filtered = projects.map((p: Project) => {
+                    const { id, name, path_with_namespace, ssh_url_to_repo } = p
+                    return { id, name, path_with_namespace, ssh_url_to_repo }
+                })
+                console.log(filtered)
+            }
+        })
+    return program
+}
+
+if (isMain('git-lab-projects')) {
+    await create().parseAsync(Bun.argv)
+}
+
+export default create

package/bin/git-lab-whoami.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun run
+
+import { Command } from 'commander'
+import { whoami, type User } from "../lib/gitlab"
+import { isMain } from '../lib/is_main'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('whoami')
+        .description('get GitLab user information for current user')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (options) => {
+            const user: User = await whoami()
+            if (!user) {
+                console.error(`No user!`)
+                process.exit(1)
+            }
+            if (options.verbose) {
+                console.log(user)
+                process.exit(0)
+            }
+            else {
+                console.log(user.username)
+            }
+        })
+    return program
+}
+
+if (isMain('git-lab-whoami')) {
+    await create().parseAsync(Bun.argv)
+}
+
+export default create

package/bin/git-lab.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun run
+
+import { Command } from 'commander'
+import { isMain } from '../lib/is_main'
+import whoami from './git-lab-whoami'
+import projects from './git-lab-projects'
+
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('lab')
+        .description('A set of commands for working with GitLab')
+        .addCommand(whoami())
+        .addCommand(projects())
+    return program
+}
+
+if (isMain('git-jira')) {
+    await create().parseAsync(Bun.argv)
+}
+
+export default create

package/bin/gitj.ts

@@ -1,24 +1,27 @@
 #!/usr/bin/env bun run
 
-// 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