git-stack-cli 1.12.0 → 1.13.1

package/src/app/PreManualRebase.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 
-import fs from "node:fs";
+import fs from "node:fs/promises";
 import path from "node:path";
 
 import * as Ink from "ink-cjs";
@@ -11,6 +11,7 @@ import { FormatText } from "~/app/FormatText";
 import { Store } from "~/app/Store";
 import { colors } from "~/core/colors";
 import { invariant } from "~/core/invariant";
+import { safe_exists } from "~/core/safe_exists";
 
 export function PreManualRebase() {
   return <Await fallback={null} function={run} />;
@@ -40,8 +41,8 @@ async function run() {
   for (const key of PR_TEMPLATE_KEY_LIST) {
     const pr_template_fn = PR_TEMPLATE[key as keyof typeof PR_TEMPLATE];
 
-    if (fs.existsSync(pr_template_fn(repo_root))) {
-      pr_template_body = fs.readFileSync(pr_template_fn(repo_root), "utf-8");
+    if (await safe_exists(pr_template_fn(repo_root))) {
+      pr_template_body = await fs.readFile(pr_template_fn(repo_root), "utf-8");
 
       actions.output(
         <FormatText
@@ -59,8 +60,8 @@ async function run() {
 
   // ./.github/PULL_REQUEST_TEMPLATE/*.md
   let pr_templates: Array<string> = [];
-  if (fs.existsSync(PR_TEMPLATE.TemplateDir(repo_root))) {
-    pr_templates = fs.readdirSync(PR_TEMPLATE.TemplateDir(repo_root));
+  if (await safe_exists(PR_TEMPLATE.TemplateDir(repo_root))) {
+    pr_templates = await fs.readdir(PR_TEMPLATE.TemplateDir(repo_root));
   }
 
   // check if repo has multiple pr templates

package/src/app/RebaseCheck.tsx

@@ -1,6 +1,5 @@
 import * as React from "react";
 
-import fs from "node:fs";
 import path from "node:path";
 
 import * as Ink from "ink-cjs";
@@ -11,6 +10,7 @@ import { Store } from "~/app/Store";
 import { YesNoPrompt } from "~/app/YesNoPrompt";
 import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
+import { safe_exists } from "~/core/safe_exists";
 
 type Props = {
   children: React.ReactNode;
@@ -74,8 +74,8 @@ export function RebaseCheck(props: Props) {
       const git_dir = (await cli(`git rev-parse --absolute-git-dir`)).stdout;
 
       let is_rebase = false;
-      is_rebase ||= fs.existsSync(path.join(git_dir, "rebase-apply"));
-      is_rebase ||= fs.existsSync(path.join(git_dir, "rebase-merge"));
+      is_rebase ||= await safe_exists(path.join(git_dir, "rebase-apply"));
+      is_rebase ||= await safe_exists(path.join(git_dir, "rebase-merge"));
 
       const status = is_rebase ? "prompt" : "done";
       patch({ status });

package/src/app/Store.tsx

@@ -24,6 +24,11 @@ type MutateOutputArgs = {
   withoutTimestamp?: boolean;
 };
 
+type SyncGithubState = {
+  commit_range: CommitMetadata.CommitRange;
+  rebase_group_index: number;
+};
+
 export type State = {
   // set immediately in `index.tsx` so no `null` scenario
   process_argv: Array<string>;
@@ -41,6 +46,7 @@ export type State = {
   commit_map: null | CommitMap;
   pr_templates: Array<string>;
   pr_template_body: null | string;
+  sync_github: null | SyncGithubState;
 
   step:
     | "github-api-error"
@@ -52,6 +58,7 @@ export type State = {
     | "select-commit-ranges"
     | "pre-manual-rebase"
     | "manual-rebase"
+    | "sync-github"
     | "post-rebase-status";
 
   output: Array<React.ReactNode>;
@@ -105,6 +112,7 @@ const BaseStore = createStore<State>()(
     commit_map: null,
     pr_templates: [],
     pr_template_body: null,
+    sync_github: null,
 
     step: "loading",
 

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/command.ts

@@ -52,11 +52,6 @@ export async function command() {
   );
 }
 
-const Rebase = Object.freeze({
-  "git-revise": "git-revise",
-  "cherry-pick": "cherry-pick",
-});
-
 const GlobalOptions = {
   verbose: {
     type: "boolean",
@@ -95,17 +90,6 @@ const DefaultOptions = {
       "Run git hooks such as pre-commit and pre-push, disable with --no-verify",
   },
 
-  "rebase": {
-    type: "string",
-    choices: [Rebase["git-revise"], Rebase["cherry-pick"]],
-    default: Rebase["git-revise"],
-    description: [
-      "Strategy used for syncing branches",
-      `${Rebase["git-revise"]}: perform faster in-memory rebase`,
-      `${Rebase["cherry-pick"]}: use disk and incrementally rebase each commit`,
-    ].join(" | "),
-  },
-
   "update": {
     type: "boolean",
     alias: ["u", "upgrade"],

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()}`;
 
@@ -111,9 +134,8 @@ Rebase.run = async function run() {
       await cli(`git cherry-pick --keep-redundant-commits ${sha_list}`);
     }
 
-    // after all commits have been cherry-picked and amended
-    // move the branch pointer to the newly created temporary branch
-    // now we are locally in sync with github and on the original branch
+    // after all commits have been cherry-picked move the pointer
+    // of original branch to the newly created temporary branch
     await cli(`git branch -f ${branch_name} ${temp_branch_name}`);
 
     restore_git();
@@ -144,7 +166,7 @@ Rebase.run = async function run() {
       }
     }
 
-    handle_exit();
+    handle_exit(20);
   }
 
   // cleanup git operations if cancelled during manual rebase
@@ -154,9 +176,6 @@ Rebase.run = async function run() {
     // all children processes receive the SIGINT signal
     const spawn_options = { ignoreExitCode: true };
 
-    // always clean up any patch files
-    cli.sync(`rm ${PATCH_FILE}`, spawn_options);
-
     // always hard reset and clean to allow subsequent checkout
     // if there are files checkout will fail and cascade fail subsequent commands
     cli.sync(`git reset --hard`, spawn_options);
@@ -168,13 +187,6 @@ Rebase.run = async function run() {
     // ...and cleanup temporary branch
     cli.sync(`git branch -D ${temp_branch_name}`, spawn_options);
 
-    if (commit_range) {
-      // ...and cleanup pr group branches
-      for (const group of commit_range.group_list) {
-        cli.sync(`git branch -D ${group.id}`, spawn_options);
-      }
-    }
-
     // restore back to original dir
     if (fs.existsSync(cwd)) {
       process.chdir(cwd);
@@ -182,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>…
@@ -197,8 +209,6 @@ Rebase.run = async function run() {
       </Ink.Text>
     );
 
-    actions.exit(6);
+    actions.exit(code);
   }
 };
-
-const PATCH_FILE = "git-stack-cli-patch.patch";

package/src/core/GitReviseTodo.ts

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
@@ -120,10 +120,10 @@ GitReviseTodo.execute = async function grt_execute(args: ExecuteArgs) {
   const GIT_SEQUENCE_EDITOR_SCRIPT = `process.env.GIT_SEQUENCE_EDITOR_SCRIPT`;
 
   // write script to temporary path
-  fs.writeFileSync(tmp_git_sequence_editor_path, GIT_SEQUENCE_EDITOR_SCRIPT);
+  await fs.writeFile(tmp_git_sequence_editor_path, GIT_SEQUENCE_EDITOR_SCRIPT);
 
   // ensure script is executable
-  fs.chmodSync(tmp_git_sequence_editor_path, "755");
+  await fs.chmod(tmp_git_sequence_editor_path, "755");
 
   const git_revise_todo = GitReviseTodo(args);
 

package/src/core/github.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 
-import fs from "node:fs";
+import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
@@ -12,6 +12,7 @@ import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
 import { invariant } from "~/core/invariant";
 import { safe_quote } from "~/core/safe_quote";
+import { safe_rm } from "~/core/safe_rm";
 
 export async function pr_list(): Promise<Array<PullRequest>> {
   const state = Store.getState();
@@ -148,7 +149,8 @@ export async function pr_edit(args: EditPullRequestArgs) {
   const command_parts = [`gh pr edit ${args.branch} --base ${args.base}`];
 
   if (args.body) {
-    command_parts.push(`--body-file="${body_file(args.body)}"`);
+    const body_file = await write_body_file(args);
+    command_parts.push(`--body-file="${body_file}"`);
   }
 
   const command = command_parts.join(" ");
@@ -166,6 +168,10 @@ type DraftPullRequestArgs = {
 };
 
 export async function pr_draft(args: DraftPullRequestArgs) {
+  // https://cli.github.com/manual/gh_api
+  // https://docs.github.com/en/graphql/reference/mutations#convertpullrequesttodraft
+  // https://docs.github.com/en/graphql/reference/mutations#markpullrequestreadyforreview
+
   const mutation_name = args.draft
     ? "convertPullRequestToDraft"
     : "markPullRequestReadyForReview";
@@ -220,7 +226,7 @@ async function gh_json<T>(command: string): Promise<T | Error> {
   }
 
   // read from file
-  const json_str = fs.readFileSync(tmp_pr_json, "utf-8");
+  const json_str = await fs.readFile(tmp_pr_json, "utf-8");
   const json = JSON.parse(json_str);
   return json;
 }
@@ -237,13 +243,16 @@ function handle_error(output: string): never {
 }
 
 // convert a string to a file for use via github cli `--body-file`
-function body_file(body: string) {
+async function write_body_file(args: EditPullRequestArgs) {
+  invariant(args.body, "args.body must exist");
+
   const temp_dir = os.tmpdir();
-  const temp_path = path.join(temp_dir, "git-stack-body");
-  if (fs.existsSync(temp_path)) {
-    fs.rmSync(temp_path);
-  }
-  fs.writeFileSync(temp_path, body);
+  const temp_path = path.join(temp_dir, `git-stack-body-${args.base}`);
+
+  await safe_rm(temp_path);
+
+  await fs.writeFile(temp_path, args.body);
+
   return temp_path;
 }
 

package/src/core/read_json.ts

@@ -1,8 +1,8 @@
-import fs from "node:fs";
+import fs from "node:fs/promises";
 
-export function read_json<T = unknown>(path: string): null | T {
+export async function read_json<T = unknown>(path: string): Promise<null | T> {
   try {
-    const file_buffer = fs.readFileSync(path);
+    const file_buffer = await fs.readFile(path);
     const json_str = String(file_buffer);
     const json = JSON.parse(json_str);
     return json;

package/src/core/safe_exists.ts

@@ -0,0 +1,10 @@
+import fs from "node:fs/promises";
+
+export async function safe_exists(filepath: string) {
+  try {
+    await fs.access(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/core/safe_rm.ts

@@ -0,0 +1,10 @@
+import fs from "node:fs/promises";
+
+export async function safe_rm(filepath: string) {
+  try {
+    await fs.access(filepath);
+    await fs.rm(filepath);
+  } catch {
+    // if access fails there is no file to remove this is safe
+  }
+}

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;