git-stack-cli 1.13.0 → 1.13.1

package/src/app/SyncGithub.tsx

@@ -0,0 +1,322 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+import last from "lodash/last";
+
+import { Await } from "~/app/Await";
+import { Store } from "~/app/Store";
+import * as StackSummaryTable from "~/core/StackSummaryTable";
+import { cli } from "~/core/cli";
+import { colors } from "~/core/colors";
+import * as github from "~/core/github";
+import { invariant } from "~/core/invariant";
+
+import type * as CommitMetadata from "~/core/CommitMetadata";
+
+export function SyncGithub() {
+  const abort_handler = React.useRef(() => {});
+
+  React.useEffect(function listen_sigint() {
+    process.once("SIGINT", sigint_handler);
+
+    return function cleanup() {
+      process.removeListener("SIGINT", sigint_handler);
+    };
+
+    function sigint_handler() {
+      abort_handler.current();
+    }
+  }, []);
+
+  return (
+    <Await
+      fallback={<Ink.Text color={colors.yellow}>Syncing…</Ink.Text>}
+      function={async function () {
+        await run({ abort_handler });
+      }}
+    />
+  );
+}
+
+type Args = {
+  abort_handler: React.MutableRefObject<() => void>;
+};
+
+async function run(args: Args) {
+  const state = Store.getState();
+  const actions = state.actions;
+  const argv = state.argv;
+  const branch_name = state.branch_name;
+  const commit_map = state.commit_map;
+  const master_branch = state.master_branch;
+  const repo_root = state.repo_root;
+  const sync_github = state.sync_github;
+
+  invariant(branch_name, "branch_name must exist");
+  invariant(commit_map, "commit_map must exist");
+  invariant(repo_root, "repo_root must exist");
+  invariant(sync_github, "sync_github must exist");
+
+  const commit_range = sync_github.commit_range;
+  const rebase_group_index = sync_github.rebase_group_index;
+
+  // always listen for SIGINT event and restore pr state
+  args.abort_handler.current = function sigint_handler() {
+    actions.output(<Ink.Text color={colors.red}>🚨 Abort</Ink.Text>);
+    handle_exit(17);
+  };
+
+  let DEFAULT_PR_BODY = "";
+  if (state.pr_template_body) {
+    DEFAULT_PR_BODY = state.pr_template_body;
+  }
+
+  const push_group_list = get_push_group_list();
+
+  // for all push targets in push_group_list
+  // things that can be done in parallel are grouped by numbers
+  //
+  // -----------------------------------
+  // 1 (before_push) temp mark draft
+  // --------------------------------------
+  // 2 push simultaneously to github
+  // --------------------------------------
+  // 2 create PR / edit PR
+  // 2 (after_push) undo temp mark draft
+  // --------------------------------------
+
+  try {
+    const before_push_tasks = [];
+    for (const group of push_group_list) {
+      before_push_tasks.push(before_push({ group }));
+    }
+
+    await Promise.all(before_push_tasks);
+
+    // git push -f origin HEAD~6:OtVX7Qvrw HEAD~3:E63ytp5dj HEAD~2:gs-NBabNSjXA HEAD~1:gs-UGVJdKNoD HEAD~0:gs-6LAx-On4
+
+    const git_push_command = [`git push -f origin`];
+
+    if (argv.verify === false) {
+      git_push_command.push("--no-verify");
+    }
+
+    for (const group of push_group_list) {
+      const last_commit = last(group.commits);
+      invariant(last_commit, "last_commit must exist");
+      const target = `${last_commit.sha}:${group.id}`;
+      git_push_command.push(target);
+    }
+
+    await cli(git_push_command);
+
+    const pr_url_list = commit_range.group_list.map(get_group_url);
+
+    const after_push_tasks = [];
+    for (const group of push_group_list) {
+      after_push_tasks.push(after_push({ group, pr_url_list }));
+    }
+
+    await Promise.all(after_push_tasks);
+
+    // finally, ensure all prs have the updated stack table from updated pr_url_list
+    // this step must come after the after_push since that step may create new PRs
+    // we need the urls for all prs at this step so we run it after the after_push
+    const update_pr_body_tasks = [];
+    for (let i = 0; i < commit_range.group_list.length; i++) {
+      const group = commit_range.group_list[i];
+
+      // use the updated pr_url_list to get the actual selected_url
+      const selected_url = pr_url_list[i];
+
+      const task = update_pr_body({ group, selected_url, pr_url_list });
+      update_pr_body_tasks.push(task);
+    }
+
+    await Promise.all(update_pr_body_tasks);
+
+    actions.set((state) => {
+      state.step = "post-rebase-status";
+    });
+  } catch (err) {
+    if (err instanceof Error) {
+      actions.error(err.message);
+    }
+
+    actions.error("Unable to sync.");
+    if (!argv.verbose) {
+      actions.error("Try again with `--verbose` to see more information.");
+    }
+
+    await handle_exit(18);
+  }
+
+  function get_push_group_list() {
+    // start from HEAD and work backward to rebase_group_index
+    const push_group_list = [];
+
+    for (let i = 0; i < commit_range.group_list.length; i++) {
+      const index = commit_range.group_list.length - 1 - i;
+
+      // do not go past rebase_group_index
+      if (index < rebase_group_index) {
+        break;
+      }
+
+      const group = commit_range.group_list[index];
+
+      push_group_list.unshift(group);
+    }
+
+    return push_group_list;
+  }
+
+  async function before_push(args: { group: CommitMetadataGroup }) {
+    const { group } = args;
+
+    invariant(group.base, "group.base must exist");
+
+    // we may temporarily mark PR as a draft before editing it
+    // if it is not already a draft PR, to avoid notification spam
+    let is_temp_draft = !group.pr?.isDraft;
+
+    // before pushing reset base to master temporarily
+    // avoid accidentally pointing to orphaned parent commit
+    // should hopefully fix issues where a PR includes a bunch of commits after pushing
+    if (group.pr) {
+      if (!group.pr.isDraft) {
+        is_temp_draft = true;
+      }
+
+      if (is_temp_draft) {
+        await github.pr_draft({
+          branch: group.id,
+          draft: true,
+        });
+      }
+
+      await github.pr_edit({
+        branch: group.id,
+        base: master_branch,
+      });
+    }
+  }
+
+  async function after_push(args: {
+    group: CommitMetadataGroup;
+    pr_url_list: Array<string>;
+  }) {
+    const { group, pr_url_list } = args;
+
+    invariant(group.base, "group.base must exist");
+
+    const selected_url = get_group_url(group);
+
+    if (group.pr) {
+      // ensure base matches pr in github
+      await github.pr_edit({
+        branch: group.id,
+        base: group.base,
+        body: StackSummaryTable.write({
+          body: group.pr.body,
+          pr_url_list,
+          selected_url,
+        }),
+      });
+
+      // we may temporarily mark PR as a draft before editing it
+      // if it is not already a draft PR, to avoid notification spam
+      let is_temp_draft = !group.pr?.isDraft;
+
+      if (is_temp_draft) {
+        // mark pr as ready for review again
+        await github.pr_draft({
+          branch: group.id,
+          draft: false,
+        });
+      }
+    } else {
+      // create pr in github
+      const pr_url = await github.pr_create({
+        branch: group.id,
+        base: group.base,
+        title: group.title,
+        body: DEFAULT_PR_BODY,
+        draft: argv.draft,
+      });
+
+      if (!pr_url) {
+        throw new Error("unable to create pr");
+      }
+
+      // update pr_url_list with created pr_url
+      for (let i = 0; i < pr_url_list.length; i++) {
+        const url = pr_url_list[i];
+        if (url === selected_url) {
+          pr_url_list[i] = pr_url;
+        }
+      }
+    }
+  }
+
+  async function update_pr_body(args: {
+    group: CommitMetadataGroup;
+    selected_url: string;
+    pr_url_list: Array<string>;
+  }) {
+    const { group, selected_url, pr_url_list } = args;
+
+    invariant(group.base, "group.base must exist");
+
+    const body = group.pr?.body || DEFAULT_PR_BODY;
+
+    const update_body = StackSummaryTable.write({
+      body,
+      pr_url_list,
+      selected_url,
+    });
+
+    if (update_body === body) {
+      actions.debug(`Skipping body update for ${selected_url}`);
+    } else {
+      actions.debug(`Update body for ${selected_url}`);
+
+      await github.pr_edit({
+        branch: group.id,
+        base: group.base,
+        body: update_body,
+      });
+    }
+  }
+
+  function handle_exit(code: number) {
+    actions.output(
+      <Ink.Text color={colors.yellow}>Restoring PR state…</Ink.Text>
+    );
+
+    for (const group of push_group_list) {
+      // we may temporarily mark PR as a draft before editing it
+      // if it is not already a draft PR, to avoid notification spam
+      let is_temp_draft = !group.pr?.isDraft;
+
+      // restore PR to non-draft state
+      if (is_temp_draft) {
+        github
+          .pr_draft({
+            branch: group.id,
+            draft: false,
+          })
+          .catch(actions.error);
+      }
+    }
+
+    actions.output(
+      <Ink.Text color={colors.yellow}>Restored PR state.</Ink.Text>
+    );
+
+    actions.exit(code);
+  }
+}
+
+type CommitMetadataGroup = CommitMetadata.CommitRange["group_list"][number];
+const get_group_url = (group: CommitMetadataGroup) => group.pr?.url || group.id;

package/src/commands/Rebase.tsx

@@ -16,15 +16,35 @@ import { invariant } from "~/core/invariant";
 import { short_id } from "~/core/short_id";
 
 export function Rebase() {
+  const abort_handler = React.useRef(() => {});
+
+  React.useEffect(function listen_sigint() {
+    process.once("SIGINT", sigint_handler);
+
+    return function cleanup() {
+      process.removeListener("SIGINT", sigint_handler);
+    };
+
+    function sigint_handler() {
+      abort_handler.current();
+    }
+  }, []);
+
   return (
     <Await
-      function={Rebase.run}
       fallback={<Ink.Text color={colors.yellow}>Rebasing commits…</Ink.Text>}
+      function={async function () {
+        await Rebase.run({ abort_handler });
+      }}
     />
   );
 }
 
-Rebase.run = async function run() {
+type Args = {
+  abort_handler: React.MutableRefObject<() => void>;
+};
+
+Rebase.run = async function run(args: Args) {
   const state = Store.getState();
   const actions = state.actions;
   const branch_name = state.branch_name;
@@ -38,7 +58,10 @@ Rebase.run = async function run() {
   invariant(repo_root, "repo_root must exist");
 
   // always listen for SIGINT event and restore git state
-  process.once("SIGINT", handle_exit);
+  args.abort_handler.current = async function sigint_handler() {
+    actions.output(<Ink.Text color={colors.red}>🚨 Abort</Ink.Text>);
+    handle_exit(19);
+  };
 
   const temp_branch_name = `${branch_name}_${short_id()}`;
 
@@ -143,7 +166,7 @@ Rebase.run = async function run() {
       }
     }
 
-    handle_exit();
+    handle_exit(20);
   }
 
   // cleanup git operations if cancelled during manual rebase
@@ -171,7 +194,7 @@ Rebase.run = async function run() {
     cli.sync(`pwd`, spawn_options);
   }
 
-  function handle_exit() {
+  function handle_exit(code: number) {
     actions.output(
       <Ink.Text color={colors.yellow}>
         Restoring <Brackets>{branch_name}</Brackets>…
@@ -186,6 +209,6 @@ Rebase.run = async function run() {
       </Ink.Text>
     );
 
-    actions.exit(6);
+    actions.exit(code);
   }
 };

package/src/index.tsx

@@ -10,7 +10,10 @@ import { command } from "~/command";
 
 command()
   .then((argv) => {
-    const ink = Ink.render(<App />);
+    const ink = Ink.render(<App />, {
+      // If true, each update will be rendered as a separate output, without replacing the previous one.
+      // debug: true,
+    });
 
     Store.setState((state) => {
       state.ink = ink;