ya-git-jira 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# git-jira
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.0.0. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/bin/bump.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+
+import { createBranch, getCurrentBranch } from "../lib/git"
+
+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)
+

package/bin/start.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import minimist from "minimist"
+import { createBranch } from "../lib/git"
+import { getIssue } from "../lib/jira"
+
+const argv = minimist(process.argv.slice(2))
+if (argv._.length !== 1) {
+    console.error("Usage: start <issue>")
+    process.exit(1)
+}
+
+const issueId = argv._[0]
+const issue = await getIssue(issueId)
+const summary = issue.fields.summary
+
+function toKebab(s: string): string {
+    return s.replace(/([a-z]+)([A-Z]+)/g, "$1_2").toLowerCase()
+        .replace(/(\W+)/g, "-")
+        .replace(/-$/, "")
+}
+
+const branchName = `${issueId}-${toKebab(summary)}`
+await createBranch(branchName)

package/dist/bin/bump.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// lib/git.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();
+}
+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"]);
+}
+
+// bin/bump.ts
+var currentBranch = await getCurrentBranch();
+var stem = currentBranch;
+var version = 1;
+var match = currentBranch.match(/^(.+)[-\.]v(\d+)$/);
+if (match) {
+  stem = match[1];
+  version = parseInt(match[2]) + 1;
+}
+var nextBranch = `${stem}.v${version}`;
+await createBranch(nextBranch);

package/dist/bin/start.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/minimist/index.js
+var require_minimist = __commonJS((exports, module) => {
+  var hasKey = function(obj, keys) {
+    var o = obj;
+    keys.slice(0, -1).forEach(function(key2) {
+      o = o[key2] || {};
+    });
+    var key = keys[keys.length - 1];
+    return key in o;
+  };
+  var isNumber = function(x) {
+    if (typeof x === "number") {
+      return true;
+    }
+    if (/^0x[0-9a-f]+$/i.test(x)) {
+      return true;
+    }
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+  };
+  var isConstructorOrProto = function(obj, key) {
+    return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+  };
+  module.exports = function(args, opts) {
+    if (!opts) {
+      opts = {};
+    }
+    var flags = {
+      bools: {},
+      strings: {},
+      unknownFn: null
+    };
+    if (typeof opts.unknown === "function") {
+      flags.unknownFn = opts.unknown;
+    }
+    if (typeof opts.boolean === "boolean" && opts.boolean) {
+      flags.allBools = true;
+    } else {
+      [].concat(opts.boolean).filter(Boolean).forEach(function(key2) {
+        flags.bools[key2] = true;
+      });
+    }
+    var aliases = {};
+    function aliasIsBoolean(key2) {
+      return aliases[key2].some(function(x) {
+        return flags.bools[x];
+      });
+    }
+    Object.keys(opts.alias || {}).forEach(function(key2) {
+      aliases[key2] = [].concat(opts.alias[key2]);
+      aliases[key2].forEach(function(x) {
+        aliases[x] = [key2].concat(aliases[key2].filter(function(y) {
+          return x !== y;
+        }));
+      });
+    });
+    [].concat(opts.string).filter(Boolean).forEach(function(key2) {
+      flags.strings[key2] = true;
+      if (aliases[key2]) {
+        [].concat(aliases[key2]).forEach(function(k) {
+          flags.strings[k] = true;
+        });
+      }
+    });
+    var defaults = opts.default || {};
+    var argv = { _: [] };
+    function argDefined(key2, arg2) {
+      return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
+    }
+    function setKey(obj, keys, value2) {
+      var o = obj;
+      for (var i2 = 0;i2 < keys.length - 1; i2++) {
+        var key2 = keys[i2];
+        if (isConstructorOrProto(o, key2)) {
+          return;
+        }
+        if (o[key2] === undefined) {
+          o[key2] = {};
+        }
+        if (o[key2] === Object.prototype || o[key2] === Number.prototype || o[key2] === String.prototype) {
+          o[key2] = {};
+        }
+        if (o[key2] === Array.prototype) {
+          o[key2] = [];
+        }
+        o = o[key2];
+      }
+      var lastKey = keys[keys.length - 1];
+      if (isConstructorOrProto(o, lastKey)) {
+        return;
+      }
+      if (o === Object.prototype || o === Number.prototype || o === String.prototype) {
+        o = {};
+      }
+      if (o === Array.prototype) {
+        o = [];
+      }
+      if (o[lastKey] === undefined || flags.bools[lastKey] || typeof o[lastKey] === "boolean") {
+        o[lastKey] = value2;
+      } else if (Array.isArray(o[lastKey])) {
+        o[lastKey].push(value2);
+      } else {
+        o[lastKey] = [o[lastKey], value2];
+      }
+    }
+    function setArg(key2, val, arg2) {
+      if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
+        if (flags.unknownFn(arg2) === false) {
+          return;
+        }
+      }
+      var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
+      setKey(argv, key2.split("."), value2);
+      (aliases[key2] || []).forEach(function(x) {
+        setKey(argv, x.split("."), value2);
+      });
+    }
+    Object.keys(flags.bools).forEach(function(key2) {
+      setArg(key2, defaults[key2] === undefined ? false : defaults[key2]);
+    });
+    var notFlags = [];
+    if (args.indexOf("--") !== -1) {
+      notFlags = args.slice(args.indexOf("--") + 1);
+      args = args.slice(0, args.indexOf("--"));
+    }
+    for (var i = 0;i < args.length; i++) {
+      var arg = args[i];
+      var key;
+      var next;
+      if (/^--.+=/.test(arg)) {
+        var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+        key = m[1];
+        var value = m[2];
+        if (flags.bools[key]) {
+          value = value !== "false";
+        }
+        setArg(key, value, arg);
+      } else if (/^--no-.+/.test(arg)) {
+        key = arg.match(/^--no-(.+)/)[1];
+        setArg(key, false, arg);
+      } else if (/^--.+/.test(arg)) {
+        key = arg.match(/^--(.+)/)[1];
+        next = args[i + 1];
+        if (next !== undefined && !/^(-|--)[^-]/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+          setArg(key, next, arg);
+          i += 1;
+        } else if (/^(true|false)$/.test(next)) {
+          setArg(key, next === "true", arg);
+          i += 1;
+        } else {
+          setArg(key, flags.strings[key] ? "" : true, arg);
+        }
+      } else if (/^-[^-]+/.test(arg)) {
+        var letters = arg.slice(1, -1).split("");
+        var broken = false;
+        for (var j = 0;j < letters.length; j++) {
+          next = arg.slice(j + 2);
+          if (next === "-") {
+            setArg(letters[j], next, arg);
+            continue;
+          }
+          if (/[A-Za-z]/.test(letters[j]) && next[0] === "=") {
+            setArg(letters[j], next.slice(1), arg);
+            broken = true;
+            break;
+          }
+          if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+            setArg(letters[j], next, arg);
+            broken = true;
+            break;
+          }
+          if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+            setArg(letters[j], arg.slice(j + 2), arg);
+            broken = true;
+            break;
+          } else {
+            setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg);
+          }
+        }
+        key = arg.slice(-1)[0];
+        if (!broken && key !== "-") {
+          if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+            setArg(key, args[i + 1], arg);
+            i += 1;
+          } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+            setArg(key, args[i + 1] === "true", arg);
+            i += 1;
+          } else {
+            setArg(key, flags.strings[key] ? "" : true, arg);
+          }
+        }
+      } else {
+        if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+          argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
+        }
+        if (opts.stopEarly) {
+          argv._.push.apply(argv._, args.slice(i + 1));
+          break;
+        }
+      }
+    }
+    Object.keys(defaults).forEach(function(k) {
+      if (!hasKey(argv, k.split("."))) {
+        setKey(argv, k.split("."), defaults[k]);
+        (aliases[k] || []).forEach(function(x) {
+          setKey(argv, x.split("."), defaults[k]);
+        });
+      }
+    });
+    if (opts["--"]) {
+      argv["--"] = notFlags.slice();
+    } else {
+      notFlags.forEach(function(k) {
+        argv._.push(k);
+      });
+    }
+    return argv;
+  };
+});
+
+// bin/start.ts
+var import_minimist = __toESM(require_minimist(), 1);
+
+// lib/git.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();
+}
+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"]);
+}
+
+// lib/jira.ts
+async function get(endpoint) {
+  const method = "GET";
+  const { host, token } = await getJiraConfig();
+  const base = `https://${host}/rest/api/3`;
+  const uri = `${base}/${endpoint}`;
+  const auth = `Basic ${token}`;
+  const headers = new Headers;
+  headers.append("Authorization", auth);
+  headers.append("Accept", "application/json");
+  const options = {
+    method,
+    headers
+  };
+  const request = new Request(uri, options);
+  const response = await fetch(request);
+  return await response.json();
+}
+async function getIssue(issue) {
+  return await get(`/issue/${issue}`);
+}
+async function getMyself() {
+  return await get("/myself");
+}
+
+// bin/start.ts
+var toKebab = function(s) {
+  return s.replace(/([a-z]+)([A-Z]+)/g, "$1_2").toLowerCase().replace(/(\W+)/g, "-").replace(/-$/, "");
+};
+var argv = import_minimist.default(process.argv.slice(2));
+if (argv._.length !== 1) {
+  console.error("Usage: start <issue>");
+  process.exit(1);
+}
+var issueId = argv._[0];
+var issue = await getIssue(issueId);
+var summary = issue.fields.summary;
+var branchName = `${issueId}-${toKebab(summary)}`;
+await createBranch(branchName);

package/dist/index.js

@@ -0,0 +1,78 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// lib/git.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();
+}
+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"]);
+}
+// lib/jira.ts
+async function get(endpoint) {
+  const method = "GET";
+  const { host, token } = await getJiraConfig();
+  const base = `https://${host}/rest/api/3`;
+  const uri = `${base}/${endpoint}`;
+  const auth = `Basic ${token}`;
+  const headers = new Headers;
+  headers.append("Authorization", auth);
+  headers.append("Accept", "application/json");
+  const options = {
+    method,
+    headers
+  };
+  const request = new Request(uri, options);
+  const response = await fetch(request);
+  return await response.json();
+}
+async function getIssue(issue) {
+  return await get(`/issue/${issue}`);
+}
+async function getMyself() {
+  return await get("/myself");
+}
+export {
+  getMyself,
+  getJiraConfig,
+  getIssue,
+  getCurrentBranch,
+  getConfig,
+  get,
+  doCommand,
+  createBranch
+};

package/index.ts

@@ -0,0 +1,2 @@
+export * from "./lib/git.ts"
+export * from "./lib/jira.ts"

package/lib/git.ts

@@ -0,0 +1,35 @@
+
+
+export async function doCommand(args: string[]): Promise<string> {
+    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()
+}
+
+export async function getConfig(key: string): Promise<string> {
+    return doCommand(["git", "config", "--get", key])
+}
+
+export interface JiraConfig {
+    host: string
+    token: string
+}
+
+export async function getJiraConfig(): Promise<JiraConfig> {
+    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 }
+}
+
+export async function createBranch(name: string): Promise<string> {
+    return doCommand(["git", "checkout", "-b", name])
+}
+
+export async function getCurrentBranch(): Promise<string> {
+    return doCommand(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+}

package/lib/jira.ts

@@ -0,0 +1,42 @@
+
+import { getJiraConfig } from "../lib/git"
+
+type JSONValue =
+    | string
+    | number
+    | boolean
+    | { [x: string]: JSONValue }
+    | Array<JSONValue>
+
+export async function get(endpoint: string): Promise<JSONValue> {
+    const method = "GET"
+    const { host, token } = await getJiraConfig()
+    const base = `https://${host}/rest/api/3`
+    const uri = `${base}/${endpoint}`
+    const auth = `Basic ${token}`
+    const headers = new Headers()
+    headers.append("Authorization", auth)
+    headers.append("Accept", "application/json")
+    const options = {
+        method,
+        headers,
+    }
+    const request = new Request(uri, options)
+    const response = await fetch(request)
+    return await response.json()
+}
+
+type Issue = JSONValue & {
+    fields: {
+        summary: string
+    }
+}
+
+
+export async function getIssue(issue: string): Promise<Issue> {
+    return await get(`/issue/${issue}`) as Issue
+}
+
+export async function getMyself(): Promise<JSONValue> {
+    return await get("/myself")
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "ya-git-jira",
+  "module": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "git-jira-start": "dist/bin/start.js",
+    "git-bump": "dist/bin/bump.js"
+  },
+  "scripts": {
+    "preinstall": "bun build index.ts bin/start.ts bin/bump.ts --outdir dist"
+  },
+  "devDependencies": {
+    "bun-types": "latest"
+  },
+  "directories": {
+    "lib": "lib"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "minimist": "^1.2.8"
+  },
+  "description": "git extensions for Jira integration. Assumes bun is installed.",
+  "version": "0.0.1",
+  "main": "dist/start.js dist/bump.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jimlloyd/ya-git-jira.git"
+  },
+  "keywords": [
+    "git",
+    "jira",
+    "integration"
+  ],
+  "author": "jim.lloyd@gmail.com",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/jimlloyd/ya-git-jira/issues"
+  },
+  "homepage": "https://github.com/jimlloyd/ya-git-jira#readme"
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "composite": true,
+    "strict": true,
+    "downlevelIteration": true,
+    "skipLibCheck": true,
+    "jsx": "preserve",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowJs": true,
+    "types": [
+      "bun-types" // add Bun global
+    ]
+  }
+}