git-stack-cli 1.0.1 → 1.0.3

package/src/core/CommitMetadata.ts

@@ -0,0 +1,212 @@
+import { Store } from "~/app/Store";
+import * as Metadata from "~/core/Metadata";
+import { cli } from "~/core/cli";
+import * as github from "~/core/github";
+
+export type CommitMetadata = Awaited<ReturnType<typeof commit>>;
+export type CommitRange = Awaited<ReturnType<typeof range>>;
+
+type PullRequest = NonNullable<Awaited<ReturnType<typeof github.pr_status>>>;
+
+type CommitGroup = {
+  id: string;
+  title: string;
+  pr: null | PullRequest;
+  base: null | string;
+  dirty: boolean;
+  commits: Array<CommitMetadata>;
+};
+
+type SimpleGroup = { id: string; title: string };
+type CommitGroupMap = { [sha: string]: SimpleGroup };
+
+export async function range(commit_group_map?: CommitGroupMap) {
+  const master_branch = Store.getState().master_branch;
+
+  // gather all open prs in repo first
+  // cheaper query to populate cache
+  await github.pr_list();
+
+  const commit_list = await get_commit_list();
+
+  const pr_lookup: Record<string, void | PullRequest> = {};
+
+  let invalid = false;
+  const group_map = new Map<string, CommitGroup>();
+
+  for (const commit of commit_list) {
+    let id = commit.branch_id;
+    let title = id;
+
+    // use commit map if provided (via select commit ranges)
+    if (commit_group_map) {
+      const group = commit_group_map[commit.sha];
+
+      if (group) {
+        id = group.id;
+        title = group.title;
+      }
+    }
+
+    if (!id) {
+      // console.debug("INVALID", "MISSING ID", commit.message);
+      invalid = true;
+    }
+
+    if (id) {
+      const group_key_list = Array.from(group_map.keys());
+      const last_key = group_key_list[group_key_list.length - 1];
+
+      if (group_map.has(id) && last_key !== id) {
+        // if we've seen this id before and it's not
+        // the last added key then we are out of order
+        // console.debug("INVALID", "OUT OF ORDER", commit.message, id);
+        invalid = true;
+      }
+    } else {
+      // console.debug("INVALID", "NEW COMMIT", { commit });
+      invalid = true;
+
+      id = UNASSIGNED;
+    }
+
+    if (!title) {
+      title = id;
+    }
+
+    const group = group_map.get(id) || {
+      id,
+      title,
+      pr: null,
+      base: null,
+      dirty: false,
+      commits: [],
+    };
+
+    group.commits.push(commit);
+    group_map.set(id, group);
+  }
+
+  // check each group for dirty state and base
+  const group_value_list = Array.from(group_map.values());
+
+  const group_list = [];
+  let unassigned_group;
+
+  for (let i = 0; i < group_value_list.length; i++) {
+    const group = group_value_list[i];
+
+    if (group.id !== UNASSIGNED) {
+      const pr_result = await github.pr_status(group.id);
+
+      if (pr_result && pr_result.state !== "CLOSED") {
+        group.pr = pr_result;
+        pr_lookup[group.id] = pr_result;
+      }
+    }
+
+    // console.debug("group", group.pr?.title.substring(0, 40));
+    // console.debug("  ", "id", group.id);
+
+    if (group.id === UNASSIGNED) {
+      unassigned_group = group;
+    } else {
+      group_list.push(group);
+    }
+
+    if (i === 0) {
+      group.base = master_branch;
+    } else {
+      const last_group = group_value_list[i - 1];
+      // console.debug("  ", "last_group", last_group.pr?.title.substring(0, 40));
+      // console.debug("  ", "last_group.id", last_group.id);
+
+      // null out base when unassigned and after unassigned
+      if (group.id === UNASSIGNED) {
+        group.base = null;
+      } else if (last_group.base === null) {
+        group.base = null;
+      } else {
+        group.base = last_group.id;
+      }
+
+      // console.debug("  ", "group.base", group.base);
+    }
+
+    if (!group.pr) {
+      group.dirty = true;
+    } else if (group.pr.commits.length !== group.commits.length) {
+      group.dirty = true;
+    } else if (group.pr.baseRefName !== group.base) {
+      group.dirty = true;
+    } else {
+      for (let i = 0; i < group.pr.commits.length; i++) {
+        const pr_commit = group.pr.commits[i];
+        const local_commit = group.commits[i];
+
+        if (pr_commit.oid !== local_commit.sha) {
+          group.dirty = true;
+        }
+      }
+    }
+
+    // console.debug("  ", "group.dirty", group.dirty);
+  }
+
+  // reverse group_list to match git log
+  group_list.reverse();
+
+  // insert unassigned group at front
+  if (unassigned_group) {
+    group_list.unshift(unassigned_group);
+  }
+
+  return { invalid, group_list, commit_list, pr_lookup, UNASSIGNED };
+}
+
+async function get_commit_list() {
+  const log_result = await cli(
+    `git log master..HEAD --oneline --format=%H --color=never`
+  );
+
+  if (!log_result.stdout) {
+    return [];
+  }
+
+  const sha_list = lines(log_result.stdout).reverse();
+
+  const commit_metadata_list = [];
+
+  for (let i = 0; i < sha_list.length; i++) {
+    const sha = sha_list[i];
+    const commit_metadata = await commit(sha);
+    commit_metadata_list.push(commit_metadata);
+  }
+
+  return commit_metadata_list;
+}
+
+export async function commit(sha: string) {
+  const full_message = (await cli(`git show -s --format=%B ${sha}`)).stdout;
+  const branch_id = await Metadata.read(full_message);
+  const subject_line = get_subject_line(full_message);
+
+  return {
+    sha,
+    full_message,
+    subject_line,
+    branch_id,
+  };
+}
+
+function get_subject_line(message: string) {
+  const line_list = lines(message);
+  const first_line = line_list[0];
+  return Metadata.remove(first_line);
+}
+
+function lines(value: string) {
+  return value.split("\n");
+}
+
+const UNASSIGNED = "unassigned";

package/src/core/Metadata.test.ts

@@ -0,0 +1,41 @@
+import { test, expect } from "bun:test";
+
+import * as Metadata from "~/core/Metadata";
+
+test("read handles bulleted lists", () => {
+  const body = [
+    "[feat] implement various features",
+    "",
+    "- keyboard modality escape key",
+    "- centralize settings",
+    "- move logic inside if branch",
+    "",
+    "git-stack-id: DdKIFyufW",
+  ].join("\n");
+
+  expect(Metadata.read(body)).toEqual("DdKIFyufW");
+});
+
+test("write handles bulleted lists", () => {
+  const body = [
+    "[feat] implement various features",
+    "",
+    "- keyboard modality escape key",
+    "- centralize settings",
+    "- move logic inside if branch",
+    "",
+    "git-stack-id: DdKIFyufW",
+  ].join("\n");
+
+  expect(Metadata.write(body, "abcd1234")).toEqual(
+    [
+      "[feat] implement various features",
+      "",
+      "- keyboard modality escape key",
+      "- centralize settings",
+      "- move logic inside if branch",
+      "",
+      "git-stack-id: abcd1234",
+    ].join("\n")
+  );
+});

package/src/core/Metadata.ts

@@ -0,0 +1,51 @@
+import { invariant } from "~/core/invariant";
+import { safe_quote } from "~/core/safe_quote";
+
+export function write(message: string, stack_id: string) {
+  let result = message;
+
+  // escape double-quote for cli
+  result = safe_quote(result);
+
+  // remove any previous metadata lines
+  result = remove(result);
+
+  const line_list = [result, "", TEMPLATE.stack_id(stack_id)];
+  const new_message = line_list.join("\n");
+
+  return new_message;
+}
+
+export function read(message: string): null | string {
+  const match = message.match(RE.stack_id);
+
+  if (!match?.groups) {
+    return null;
+  }
+
+  const id = match.groups["id"];
+  invariant(id, "id must exist");
+
+  return id;
+}
+
+export function remove(message: string) {
+  let result = message;
+
+  // remove metadata
+  result = result.replace(new RegExp(RE.stack_id, "gmi"), "");
+
+  result = result.trimEnd();
+
+  return result;
+}
+
+const TEMPLATE = {
+  stack_id(id: string) {
+    return `git-stack-id: ${id}`;
+  },
+};
+
+const RE = {
+  stack_id: new RegExp(TEMPLATE.stack_id("(?<id>[a-z0-9-+=]+)"), "i"),
+};

package/src/core/StackSummaryTable.test.ts

@@ -0,0 +1,157 @@
+import { test, expect } from "bun:test";
+
+import * as StackSummaryTable from "~/core/StackSummaryTable";
+
+test("blank", () => {
+  const output = StackSummaryTable.write({
+    body: "",
+    pr_url_list: [],
+    selected_url: "",
+  });
+
+  expect(output).toBe("");
+});
+
+test("no prs does not modify body", () => {
+  const args = {
+    body: [
+      "## Problem,",
+      "",
+      ",Description of the problem,",
+      "",
+      ",## Solution,",
+      "",
+      ",Solved problem by doing x, y, z.",
+    ].join("\n"),
+    pr_url_list: [],
+    selected_url: "",
+  };
+
+  const output = StackSummaryTable.write(args);
+
+  expect(output).toBe(args.body);
+});
+
+test("handles bulleted lists", () => {
+  const body = [
+    "## Problem",
+    "",
+    "Description of the problem",
+    "",
+    "## Solution",
+    "",
+    "- keyboard modality escape key",
+    "- centralize settings",
+    "- move logic inside if branch",
+  ].join("\n");
+
+  const args = {
+    body,
+    pr_url_list: [],
+    selected_url: "",
+  };
+
+  const output = StackSummaryTable.write(args);
+
+  expect(output).toBe(args.body);
+});
+
+test("builds list of prs with selected emoji", () => {
+  const args = {
+    body: [
+      "## Problem,",
+      "",
+      ",Description of the problem,",
+      "",
+      ",## Solution,",
+      "",
+      ",Solved problem by doing x, y, z.",
+    ].join("\n"),
+    pr_url_list: [
+      "https://github.com/magus/git-multi-diff-playground/pull/43",
+      "https://github.com/magus/git-multi-diff-playground/pull/47",
+    ],
+    selected_url: "https://github.com/magus/git-multi-diff-playground/pull/43",
+  };
+
+  const output = StackSummaryTable.write(args);
+
+  expect(output.split("\n")).toEqual([
+    ...args.body.split("\n"),
+    "",
+    "#### git stack",
+    "- ⏳ `2` https://github.com/magus/git-multi-diff-playground/pull/47",
+    "- 👉 `1` https://github.com/magus/git-multi-diff-playground/pull/43",
+  ]);
+});
+
+test("can parse stack table from body", () => {
+  const body_line_list = [
+    "",
+    "",
+    "#### git stack",
+    "- invalid line that will be dropped",
+    "- ⏳ `2` https://github.com/magus/git-multi-diff-playground/pull/47",
+    "- 👉 `1` https://github.com/magus/git-multi-diff-playground/pull/43",
+  ];
+
+  const parsed = StackSummaryTable.parse(body_line_list.join("\n"));
+
+  expect(Array.from(parsed.entries())).toEqual([
+    [
+      "https://github.com/magus/git-multi-diff-playground/pull/47",
+      {
+        icon: "⏳",
+        num: "2",
+        pr_url: "https://github.com/magus/git-multi-diff-playground/pull/47",
+      },
+    ],
+    [
+      "https://github.com/magus/git-multi-diff-playground/pull/43",
+      {
+        icon: "👉",
+        num: "1",
+        pr_url: "https://github.com/magus/git-multi-diff-playground/pull/43",
+      },
+    ],
+  ]);
+});
+
+test("persists removed pr urls from previous stack table", () => {
+  const args = {
+    body: [
+      "Summary of problem",
+      "",
+      "#### git stack",
+      "- 👉 `3` https://github.com/magus/git-multi-diff-playground/pull/47",
+      "- ⏳ `2` https://github.com/magus/git-multi-diff-playground/pull/44",
+      "- ⏳ `1` https://github.com/magus/git-multi-diff-playground/pull/43",
+    ].join("\n"),
+
+    pr_url_list: [
+      "https://github.com/magus/git-multi-diff-playground/pull/47",
+      "https://github.com/magus/git-multi-diff-playground/pull/54",
+      "https://github.com/magus/git-multi-diff-playground/pull/61",
+    ],
+
+    selected_url: "https://github.com/magus/git-multi-diff-playground/pull/47",
+  };
+
+  const output = StackSummaryTable.write(args);
+
+  expect(output.split("\n")).toEqual([
+    "Summary of problem",
+    "",
+    "#### git stack",
+    "- ⏳ `5` https://github.com/magus/git-multi-diff-playground/pull/61",
+    "- ⏳ `4` https://github.com/magus/git-multi-diff-playground/pull/54",
+    "- 👉 `3` https://github.com/magus/git-multi-diff-playground/pull/47",
+    "- ✅ `2` https://github.com/magus/git-multi-diff-playground/pull/44",
+    "- ✅ `1` https://github.com/magus/git-multi-diff-playground/pull/43",
+  ]);
+
+  // run again on the output to make sure it doesn't change
+  const rerun_output = StackSummaryTable.write({ ...args, body: output });
+
+  expect(rerun_output).toBe(output);
+});

package/src/core/StackSummaryTable.ts

@@ -0,0 +1,127 @@
+type WriteArgs = {
+  body: string;
+  pr_url_list: Array<string>;
+  selected_url: string;
+};
+
+export function write(args: WriteArgs) {
+  const stack_table = table(args);
+
+  let result = args.body;
+
+  if (RE.stack_table.test(result)) {
+    // replace stack table
+    result = result.replace(RE.stack_table, stack_table);
+  } else {
+    // append stack table
+    result = `${result}\n\n${stack_table}`;
+  }
+
+  result = result.trimEnd();
+
+  return result;
+}
+
+export function table(args: WriteArgs) {
+  const stack_pr_url_list = [...args.pr_url_list];
+  const old_stack = parse(args.body);
+
+  // remove existing stack pr urls from the old stack pr urls
+  for (const pr_url of stack_pr_url_list) {
+    old_stack.delete(pr_url);
+  }
+
+  // add remaining old stack pr urls to the front of stack pr url list
+  for (const pr_url of old_stack.keys()) {
+    stack_pr_url_list.unshift(pr_url);
+  }
+
+  const stack_list = [];
+  const num_digits = String(stack_pr_url_list.length).length;
+
+  for (let i = 0; i < stack_pr_url_list.length; i++) {
+    const pr_url = stack_pr_url_list[i];
+
+    const selected = args.selected_url === pr_url;
+
+    let icon;
+    if (old_stack.has(pr_url)) {
+      icon = "✅";
+    } else if (selected) {
+      icon = "👉";
+    } else {
+      icon = "⏳";
+    }
+
+    const num = String(i + 1).padStart(num_digits, "0");
+
+    stack_list.push(TEMPLATE.row({ icon, num, pr_url }));
+  }
+
+  if (!stack_list.length) {
+    return "";
+  }
+
+  // reverse order of pr list to match the order of git stack
+  stack_list.reverse();
+
+  return TEMPLATE.stack_table(["", ...stack_list, "", ""].join("\n"));
+}
+
+export function parse(body: string): Map<string, StackTableRow> {
+  const stack_table_match = body.match(RE.stack_table);
+
+  if (!stack_table_match?.groups) {
+    return new Map();
+  }
+
+  const rows_string = stack_table_match.groups["rows"];
+  const row_list = rows_string.split("\n");
+
+  const result = new Map<string, StackTableRow>();
+
+  for (const row of row_list) {
+    const row_match = row.match(RE.row);
+    const parsed_row = row_match?.groups as StackTableRow;
+
+    if (!parsed_row) {
+      // skip invalid row
+      continue;
+    }
+
+    result.set(parsed_row.pr_url, parsed_row);
+  }
+
+  return result;
+}
+
+const TEMPLATE = {
+  stack_table(rows: string) {
+    return `#### git stack${rows}`;
+  },
+
+  row(args: StackTableRow) {
+    return `- ${args.icon} \`${args.num}\` ${args.pr_url}`;
+  },
+};
+
+const RE = {
+  // https://regex101.com/r/kqB9Ft/1
+  stack_table: new RegExp(
+    TEMPLATE.stack_table("\\s+(?<rows>(?:- [^\r^\n]*(?:[\r\n]+)?)+)")
+  ),
+
+  row: new RegExp(
+    TEMPLATE.row({
+      icon: "(?<icon>.+)",
+      num: "(?<num>\\d+)",
+      pr_url: "(?<pr_url>.+)",
+    })
+  ),
+};
+
+type StackTableRow = {
+  icon: string;
+  num: string;
+  pr_url: string;
+};

package/src/core/Timer.ts

@@ -0,0 +1,44 @@
+export function Timer() {
+  const start_time = Date.now();
+
+  function duration() {
+    const duration_ms = Date.now() - start_time;
+
+    if (duration_ms < MS.second) {
+      return `${duration_ms}ms`;
+    } else if (duration_ms < MS.minute) {
+      const seconds = duration_ms / MS.second;
+      return `${seconds.toFixed(1)}s`;
+    } else if (duration_ms < MS.hour) {
+      const minutes = duration_ms / MS.minute;
+      return `${minutes.toFixed(1)}min`;
+    }
+
+    const hours = duration_ms / MS.hour;
+    return `${hours.toFixed(1)}min`;
+  }
+
+  return { duration, start_time };
+}
+
+const MS = (function () {
+  const millisecond = 1;
+  const second = millisecond * 1000;
+  const minute = second * 60;
+  const hour = minute * 60;
+  const day = hour * 24;
+  const week = day * 7;
+  const month = day * 30;
+  const year = day * 365;
+
+  return {
+    millisecond,
+    second,
+    minute,
+    hour,
+    day,
+    week,
+    month,
+    year,
+  };
+})();

package/src/core/assertNever.ts

@@ -0,0 +1,4 @@
+export function assertNever(value: never): asserts value is never {
+  // eslint-disable-next-line no-console
+  console.error("[assertNever]", { value });
+}

package/src/core/cache.ts

@@ -0,0 +1,49 @@
+type Status = "pending" | "success" | "error";
+
+type Cacheable<T> = () => Promise<T>;
+
+export function cache<T, E>(cacheable: Cacheable<T>) {
+  let status: Status = "pending";
+
+  let response: void | T | E;
+  let suspender: void | Promise<void>;
+
+  function reset() {
+    status = "pending";
+    response = undefined;
+    suspender = undefined;
+  }
+
+  function check() {
+    return status;
+  }
+
+  function read() {
+    // cacheable is a function to allow deferred reads
+    // this will call cacheable to kickoff async promise
+    if (!suspender) {
+      suspender = Promise.resolve().then(() => {
+        cacheable()
+          .then((res: T) => {
+            status = "success";
+            response = res;
+          })
+          .catch((err: E) => {
+            status = "error";
+            response = err;
+          });
+      });
+    }
+
+    switch (status) {
+      case "pending":
+        throw suspender;
+      case "error":
+        throw response;
+      default:
+        return response;
+    }
+  }
+
+  return { reset, check, read };
+}

package/src/core/capitalize.ts

@@ -0,0 +1,5 @@
+export function capitalize(value: string) {
+  const first_char = value.substring(0, 1).toLocaleUpperCase();
+  const rest_char = value.substring(1, value.length);
+  return first_char + rest_char;
+}