ya-git-jira 1.2.0 → 1.3.0

package/dist/bin/gitj.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) => {
@@ -1828,23 +1784,104 @@ 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 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"]);
+}
+
+// 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();
+  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");
+}
+async function myUnresolvedIssues() {
+  const myself = await getMyself();
+  const myselfId = myself.accountId;
+  const jql = `assignee = ${myselfId} AND resolution = Unresolved`;
+  const issues = await get(`/search?jql=${encodeURIComponent(jql)}`);
+  return issues.issues;
+}
 
 // lib/is_main.ts
 import path from "path";
@@ -1852,26 +1889,172 @@ 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;
+// bin/git-jira-issues.ts
+function create() {
+  const program2 = new Command;
+  program2.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}`);
+    });
+  });
+  return program2;
+}
+if (isMain("git-jira-issues")) {
+  await create().parseAsync(Bun.argv);
+}
+var git_jira_issues_default = create;
+
+// bin/git-jira-start.ts
+var toKebab = function(s) {
+  return s.replace(/([a-z]+)([A-Z]+)/g, "$1_2").toLowerCase().replace(/(\W+)/g, "-").replace(/-$/, "");
+};
+function create2() {
+  const program2 = new Command;
+  program2.name("start").description("Start working on an issue by creating a branch").argument("issue", "Issue ID").action(async (issueId) => {
+    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);
+  });
+  return program2;
+}
+if (isMain("git-jira-issues")) {
+  await create2().parseAsync(Bun.argv);
+}
+var git_jira_start_default = create2;
+
+// bin/git-jira-issue.ts
+function create3() {
+  const program2 = new Command;
+  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`);
+      process.exit(1);
     }
-  },
-  create: () => {
-    {
-      return create;
+    if (options.verbose) {
+      console.log(issue);
+      process.exit(0);
     }
+    if (options.url) {
+      console.log(`https://${host}/browse/${issueId}`);
+    }
+  });
+  return program2;
+}
+if (isMain("git-jira-issue")) {
+  await create3().parseAsync(Bun.argv);
+}
+var git_jira_issue_default = create3;
+
+// bin/git-jira.ts
+function create4() {
+  const program2 = new Command;
+  program2.name("jira").description("A set of commands for working with Jira").addCommand(git_jira_start_default()).addCommand(git_jira_issue_default()).addCommand(git_jira_issues_default());
+  return program2;
+}
+if (isMain("git-jira")) {
+  await create4().parseAsync(Bun.argv);
+}
+var git_jira_default = create4;
+
+// lib/gitlab.ts
+import path2 from "path";
+async function getGitlabConfig() {
+  const host = await getConfig("gitlab.host");
+  if (!host)
+    throw new Error("gitlab.host not in git config");
+  const user = await getConfig("user.email");
+  if (!user)
+    throw new Error("user.email not in git config");
+  const token = await getConfig("gitlab.token");
+  if (!token)
+    throw new Error("gitlab.token not in git config");
+  return { host, user, token };
+}
+async function get2(endpoint) {
+  const method = "GET";
+  const { host, token } = await getGitlabConfig();
+  const base = `https://${host}/api/v4`;
+  const uri = `${base}/${endpoint}`;
+  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();
+}
+async function whoami() {
+  return await get2("/user");
+}
+async function getProjects(paths) {
+  let search = "";
+  if (paths.length > 0) {
+    search = "&search=" + paths.join(",");
   }
-});
-function create() {
+  return await get2(`/projects?visibility=private&membership=true&simple=true${search}`);
+}
+async function findProject(ssh_url) {
+  const parts = ssh_url.split(":");
+  if (parts.length != 2) {
+    throw new Error(`${ssh_url} is invalid, could not be split into two parts at :`);
+  }
+  const name = path2.basename(parts[1], ".git");
+  const projects = await getProjects([name]);
+  const project = projects.find((p) => {
+    return p.ssh_url_to_repo === ssh_url;
+  });
+  if (!project) {
+    throw new Error(`No project with ssh_url_to_repo ${ssh_url} found`);
+  }
+  return project;
+}
+async function getMergeRequest(id) {
+  return await get2(`/merge_requests/${id}`);
+}
+
+// bin/git-lab-projects.ts
+function create5() {
   const program2 = new Command;
-  program2.name("bump").action(async () => {
+  program2.name("projects").description("List projects for current user").option("-v, --verbose", "Verbose output").argument("[path...]", "Namespace paths to filter by").action(async (paths, options) => {
+    const projects = await getProjects(paths);
+    if (!projects) {
+      console.error(`No projects!`);
+      process.exit(1);
+    }
+    if (options.verbose) {
+      console.log(projects);
+    } else {
+      let filtered = projects.map((p) => {
+        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 program2;
+}
+if (isMain("git-lab-projects")) {
+  await create5().parseAsync(Bun.argv);
+}
+var git_lab_projects_default = create5;
+
+// bin/git-bump.ts
+function create6() {
+  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;
@@ -1885,25 +2068,55 @@ 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;
-});
+if (isMain("git-bump")) {
+  await create6().parseAsync(Bun.argv);
+}
+var git_bump_default = create6;
+
+// bin/git-lab-whoami.ts
+function create7() {
+  const program2 = new Command;
+  program2.name("whoami").description("get GitLab user information for current user").option("-v, --verbose", "Verbose output").action(async (options) => {
+    const 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 program2;
+}
+if (isMain("git-lab-whoami")) {
+  await create7().parseAsync(Bun.argv);
+}
+var git_lab_whoami_default = create7;
+
+// bin/git-lab.ts
+function create8() {
+  const program2 = new Command;
+  program2.name("lab").description("A set of commands for working with GitLab").addCommand(git_lab_whoami_default()).addCommand(git_lab_projects_default());
+  return program2;
+}
+if (isMain("git-jira")) {
+  await create8().parseAsync(Bun.argv);
+}
+var git_lab_default = create8;
 
 // bin/gitj.ts
-init_esm();
-init_is_main();
-if (isMain("gitj")) {
+function create9() {
   const program2 = new Command;
-  const bump = (await Promise.resolve().then(() => (init_git_bump(), exports_git_bump))).create();
-  program2.executableDir("./bin").addCommand(bump).command("jira", "A collection of jira utility commands", { executableFile: "git-jira" });
-  program2.action(() => {
+  program2.addCommand(git_bump_default()).addCommand(git_jira_default()).addCommand(git_lab_default()).action(() => {
     program2.help();
-  }).parse(Bun.argv);
+  });
+  return program2;
 }
+var command = create9();
+await command.parseAsync(Bun.argv);
+export {
+  create9 as create
+};

package/dist/index.js

@@ -1,3 +1,4 @@
+// @bun
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getProtoOf = Object.getPrototypeOf;
@@ -18,62 +19,123 @@ 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);
+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();
-});
-
-// lib/is_main.ts
+async function getRemote() {
+  return doCommand(["git", "ls-remote", "--get-url", "origin"]);
+}
+// lib/gitlab.ts
 import path from "path";
+async function getGitlabConfig() {
+  const host = await getConfig("gitlab.host");
+  if (!host)
+    throw new Error("gitlab.host not in git config");
+  const user = await getConfig("user.email");
+  if (!user)
+    throw new Error("user.email not in git config");
+  const token = await getConfig("gitlab.token");
+  if (!token)
+    throw new Error("gitlab.token not in git config");
+  return { host, user, token };
+}
+async function get(endpoint) {
+  const method = "GET";
+  const { host, token } = await getGitlabConfig();
+  const base = `https://${host}/api/v4`;
+  const uri = `${base}/${endpoint}`;
+  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();
+}
+async function whoami() {
+  return await get("/user");
+}
+async function getProjects(paths) {
+  let search = "";
+  if (paths.length > 0) {
+    search = "&search=" + paths.join(",");
+  }
+  return await get(`/projects?visibility=private&membership=true&simple=true${search}`);
+}
+async function findProject(ssh_url) {
+  const parts = ssh_url.split(":");
+  if (parts.length != 2) {
+    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 project = projects.find((p) => {
+    return p.ssh_url_to_repo === ssh_url;
+  });
+  if (!project) {
+    throw new Error(`No project with ssh_url_to_repo ${ssh_url} found`);
+  }
+  return project;
+}
+async function getMergeRequest(id) {
+  return await get(`/merge_requests/${id}`);
+}
+// lib/is_main.ts
+import path2 from "path";
 function isMain(self) {
-  const exe = path.basename(Bun.argv[1]).split(".")[0];
+  const exe = path2.basename(Bun.argv[1]).split(".")[0];
   return exe == self || import.meta.main;
 }
-var init_is_main = __esm(() => {
-});
-
 // lib/jira.ts
-async function get(endpoint) {
+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 get2(endpoint) {
   const method = "GET";
   const { host, token } = await getJiraConfig();
   const base = `https://${host}/rest/api/3`;
@@ -91,36 +153,33 @@ async function get(endpoint) {
   return await response.json();
 }
 async function getIssue(issue) {
-  return await get(`/issue/${issue}`);
+  return await get2(`/issue/${issue}`);
 }
 async function getMyself() {
-  return await get("/myself");
+  return await get2("/myself");
 }
 async function myUnresolvedIssues() {
   const myself = await getMyself();
   const myselfId = myself.accountId;
   const jql = `assignee = ${myselfId} AND resolution = Unresolved`;
-  const issues = await get(`/search?jql=${encodeURIComponent(jql)}`);
+  const issues = await get2(`/search?jql=${encodeURIComponent(jql)}`);
   return issues.issues;
 }
-var init_jira = __esm(() => {
-  init_git();
-});
-
-// index.ts
-init_git();
-init_is_main();
-init_jira();
-init_spawn();
 export {
+  whoami,
+  spawn,
   myUnresolvedIssues,
   isMain,
+  getRemote,
+  getProjects,
   getMyself,
+  getMergeRequest,
   getJiraConfig,
   getIssue,
+  getGitlabConfig,
   getCurrentBranch,
   getConfig,
-  get,
+  findProject,
   doCommand,
   createBranch
 };

package/index.ts

@@ -1,4 +1,6 @@
+export * from "./lib/json.ts"
 export * from "./lib/git.ts"
+export * from "./lib/gitlab.ts"
 export * from "./lib/is_main.ts"
 export * from "./lib/jira.ts"
 export * from "./lib/spawn.ts"

package/lib/git.ts

@@ -4,19 +4,6 @@ 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])
 }
@@ -24,3 +11,7 @@ export async function createBranch(name: string): Promise<string> {
 export async function getCurrentBranch(): Promise<string> {
     return doCommand(["git", "rev-parse", "--abbrev-ref", "HEAD"])
 }
+
+export async function getRemote(): Promise<string> {
+    return doCommand(['git', "ls-remote", "--get-url", "origin"])
+}