ya-git-jira 1.1.1 → 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

@@ -1,22 +1,34 @@
-#!/usr/bin/env bun
+#!/usr/bin/env bun run
 
 import { createBranch, getCurrentBranch } from "../lib/git"
-import { program } from 'commander'
+import { Command } from 'commander'
+import { isMain } from '../lib/is_main'
 
-program
-    .action(async () => {
-        const currentBranch = await getCurrentBranch()
+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()
 
-        let stem = currentBranch
-        let version = 1
+            let stem = currentBranch
+            let version = 1
 
-        const match = currentBranch.match(/^(.+)[-\.]v(\d+)$/)
-        if (match) {
-            stem = match[1]
-            version = parseInt(match[2]) + 1
-        }
+            const match = currentBranch.match(/^(.+)[-\.]v(\d+)$/)
+            if (match) {
+                stem = match[1]
+                version = parseInt(match[2]) + 1
+            }
 
-        const nextBranch = `${stem}.v${version}`
-        await createBranch(nextBranch)
-    })
-    .parse(process.argv)
+            const nextBranch = `${stem}.v${version}`
+            await createBranch(nextBranch)
+        })
+    return program
+}
+
+if (isMain('git-bump')) {
+    await create().parseAsync(Bun.argv)
+}
+
+export default create

package/bin/git-jira-issue.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env bun run
+
+import { Command } from 'commander'
+import { getIssue } from "../lib/jira"
+import { isMain } from '../lib/is_main'
+import { getJiraConfig } from '../lib/jira'
+
+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`)
+                process.exit(1)
+            }
+            if (options.verbose) {
+                console.log(issue)
+                process.exit(0)
+            }
+            if (options.url) {
+                console.log(`https://${host}/browse/${issueId}`)
+            }
+        })
+    return program
+}
+
+if (isMain('git-jira-issue')) {
+    await create().parseAsync(Bun.argv)
+}
+
+export default create

package/bin/git-jira-issues.ts

@@ -1,15 +1,26 @@
-#!/usr/bin/env bun
+#!/usr/bin/env bun run
 
-import { program } from 'commander'
+import { Command } from 'commander'
 import { myUnresolvedIssues } from "../lib/jira"
+import { isMain } from '../lib/is_main'
 
-program
-    .action(async (options) => {
-
-        const issues = await myUnresolvedIssues()
-        console.log(`You have ${issues.length} unresolved issues`)
-        issues.forEach(issue => {
-            console.log(`${issue.key}: ${issue.fields.summary}`)
+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`)
+            issues.forEach(issue => {
+                console.log(`${issue.key}: ${issue.fields.summary}`)
+            })
         })
-    })
-    .parse(process.argv)
+    return program
+}
+
+if (isMain('git-jira-issues')) {
+    await create().parseAsync(Bun.argv)
+}
+
+export default create

package/bin/git-jira-start.ts

@@ -1,8 +1,9 @@
-#!/usr/bin/env bun
+#!/usr/bin/env bun run
 
-import { program } from 'commander'
+import { Command } from 'commander'
 import { createBranch } from "../lib/git"
 import { getIssue } from "../lib/jira"
+import { isMain } from '../lib/is_main'
 
 function toKebab(s: string): string {
     return s.replace(/([a-z]+)([A-Z]+)/g, "$1_2").toLowerCase()
@@ -10,18 +11,29 @@ function toKebab(s: string): string {
         .replace(/-$/, "")
 }
 
-program
-    .argument('<issue>', 'Issue ID')
-    .action(async (issueId: string, options) => {
+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)
+            if (!issue) {
+                console.error(`Issue ${issueId} not found`)
+                process.exit(1)
+            }
+            const summary = issue.fields.summary
 
-        const issue = await getIssue(issueId)
-        if (!issue) {
-            console.error(`Issue ${issueId} not found`)
-            process.exit(1)
-        }
-        const summary = issue.fields.summary
+            const branchName = `${issueId}-${toKebab(summary)}`
+            await createBranch(branchName)
+        })
 
-        const branchName = `${issueId}-${toKebab(summary)}`
-        await createBranch(branchName)
-    })
-    .parse(process.argv)
+    return program
+}
+
+if (isMain('git-jira-issues')) {
+    await create().parseAsync(Bun.argv)
+}
+
+export default create

package/bin/git-jira.ts

@@ -1,16 +1,24 @@
-#!/usr/bin/env bun
+#!/usr/bin/env bun run
 
-// This is the root for the jira commands CLI. It's job is to parse the command
-// from the command line and then call the appropriate jira subcommand.
+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'
 
-import { program } from 'commander'
+export function create(): Command {
+    const program = new Command()
+    program
+        .name('jira')
+        .description('A set of commands for working with Jira')
+        .addCommand(start())
+        .addCommand(issue())
+        .addCommand(issues())
+    return program
+}
 
-program
-    .command('start', 'Create a new branch for a given Jira issue')
-    .command('issues', 'List your unresolved Jira issues')
+if (isMain('git-jira')) {
+    await create().parseAsync(Bun.argv)
+}
 
-program
-    .action(() => {
-        program.help()
-    })
-    .parse(process.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,17 +1,27 @@
-#!/usr/bin/env bun
+#!/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 { program } from 'commander'
+import { Command } from 'commander'
 
-program
-    .executableDir('./bin')
-    .command('bump', 'Create a new branch with an incremented version number', { executableFile: 'git-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()
+        })
+    return program
+}
 
-program
-    .action(() => {
-        program.help()
-    })
-    .parse(process.argv)
+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

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env bun run
 // @bun
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -636,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();
@@ -677,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;
@@ -863,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) => {
@@ -1028,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";
         }
       }
@@ -1042,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 {
@@ -1110,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);
             }
@@ -1135,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) => {
@@ -1153,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;
@@ -1505,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()}`);
             }
@@ -1735,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;
       }
@@ -1783,32 +1783,44 @@ var require_commander = __commonJS((exports, module) => {
   exports.Option = Option;
 });
 
-// lib/git.ts
-async function doCommand(args) {
-  const proc = Bun.spawn(args);
+// 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] = 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 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"]);
 }
+async function getRemote() {
+  return doCommand(["git", "ls-remote", "--get-url", "origin"]);
+}
 
 // node_modules/commander/esm.mjs
 var import_ = __toESM(require_commander(), 1);
@@ -1826,16 +1838,35 @@ var {
   Help
 } = import_.default;
 
+// lib/is_main.ts
+import path from "path";
+function isMain(self) {
+  const exe = path.basename(Bun.argv[1]).split(".")[0];
+  return exe == self || import.meta.main;
+}
+
 // bin/git-bump.ts
-program.action(async () => {
-  const currentBranch = await getCurrentBranch();
-  let stem = currentBranch;
-  let version = 1;
-  const match = currentBranch.match(/^(.+)[-\.]v(\d+)$/);
-  if (match) {
-    stem = match[1];
-    version = parseInt(match[2]) + 1;
-  }
-  const nextBranch = `${stem}.v${version}`;
-  await createBranch(nextBranch);
-}).parse(process.argv);
+function create() {
+  const program2 = new Command;
+  program2.name("bump").description("Bump the version number in the current branch").action(async () => {
+    const currentBranch = await getCurrentBranch();
+    let stem = currentBranch;
+    let version = 1;
+    const match = currentBranch.match(/^(.+)[-\.]v(\d+)$/);
+    if (match) {
+      stem = match[1];
+      version = parseInt(match[2]) + 1;
+    }
+    const nextBranch = `${stem}.v${version}`;
+    await createBranch(nextBranch);
+  });
+  return program2;
+}
+if (isMain("git-bump")) {
+  await create().parseAsync(Bun.argv);
+}
+var git_bump_default = create;
+export {
+  git_bump_default as default,
+  create
+};