git-stack-cli 1.9.0 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-stack-cli",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "",
   "author": "magus",
   "license": "MIT",
@@ -42,6 +42,7 @@
     "chalk": "^5.3.0",
     "immer": "^10.0.3",
     "ink-cjs": "4.4.1",
+    "lodash": "^4.17.21",
     "luxon": "^3.4.4",
     "react": "^18.2.0",
     "react-devtools-core": "^4.19.1",
@@ -57,6 +58,7 @@
     "@rollup/plugin-replace": "^5.0.5",
     "@rollup/plugin-typescript": "^11.1.6",
     "@types/chalk": "^2.2.0",
+    "@types/lodash": "^4.17.7",
     "@types/luxon": "^3.4.2",
     "@types/node": "^20.8.7",
     "@types/react": "^18.2.33",

package/src/app/App.tsx

@@ -4,6 +4,7 @@ import { AutoUpdate } from "~/app/AutoUpdate";
 import { CherryPickCheck } from "~/app/CherryPickCheck";
 import { Debug } from "~/app/Debug";
 import { DependencyCheck } from "~/app/DependencyCheck";
+import { DetectInitialPR } from "~/app/DetectInitialPR";
 import { DirtyCheck } from "~/app/DirtyCheck";
 import { GatherMetadata } from "~/app/GatherMetadata";
 import { GithubApiError } from "~/app/GithubApiError";
@@ -15,6 +16,7 @@ import { RebaseCheck } from "~/app/RebaseCheck";
 import { Store } from "~/app/Store";
 import { Fixup } from "~/commands/Fixup";
 import { Log } from "~/commands/Log";
+import { Rebase } from "~/commands/Rebase";
 
 export function App() {
   const actions = Store.useActions();
@@ -72,6 +74,14 @@ function MaybeMain() {
     return <Fixup />;
   } else if (positional_list.has("log")) {
     return <Log />;
+  } else if (positional_list.has("rebase")) {
+    return (
+      <GatherMetadata>
+        <LocalCommitStatus>
+          <Rebase />
+        </LocalCommitStatus>
+      </GatherMetadata>
+    );
   }
 
   return (
@@ -80,7 +90,9 @@ function MaybeMain() {
 
       <GatherMetadata>
         <LocalCommitStatus>
-          <Main />
+          <DetectInitialPR>
+            <Main />
+          </DetectInitialPR>
         </LocalCommitStatus>
       </GatherMetadata>
     </DirtyCheck>

package/src/app/CherryPickCheck.tsx

@@ -57,17 +57,17 @@ export function CherryPickCheck(props: Props) {
     default:
       return (
         <Await
+          function={run}
           fallback={
             <Ink.Text color={colors.yellow}>
               Checking for <Command>git cherry-pick</Command>…
             </Ink.Text>
           }
-          function={cherry_pick_check}
         />
       );
   }
 
-  async function cherry_pick_check() {
+  async function run() {
     const actions = Store.getState().actions;
 
     try {
@@ -88,7 +88,7 @@ export function CherryPickCheck(props: Props) {
         }
       }
 
-      actions.exit(9);
+      actions.exit(11);
     }
   }
 }

package/src/app/DetectInitialPR.tsx

@@ -0,0 +1,189 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+import cloneDeep from "lodash/cloneDeep";
+
+import { Await } from "~/app/Await";
+import { Brackets } from "~/app/Brackets";
+import { Command } from "~/app/Command";
+import { FormatText } from "~/app/FormatText";
+import { Store } from "~/app/Store";
+import { Url } from "~/app/Url";
+import { YesNoPrompt } from "~/app/YesNoPrompt";
+import * as CommitMetadata from "~/core/CommitMetadata";
+import { GitReviseTodo } from "~/core/GitReviseTodo";
+import { cli } from "~/core/cli";
+import { colors } from "~/core/colors";
+import * as github from "~/core/github";
+import { invariant } from "~/core/invariant";
+
+type Props = {
+  children: React.ReactNode;
+};
+
+type PullRequest = NonNullable<Awaited<ReturnType<typeof github.pr_status>>>;
+
+type State = {
+  status: "init" | "prompt" | "revise" | "done";
+  pr: null | PullRequest;
+};
+
+function reducer(state: State, patch: Partial<State>) {
+  return { ...state, ...patch };
+}
+
+export function DetectInitialPR(props: Props) {
+  const actions = Store.useActions();
+  const branch_name = Store.useState((state) => state.branch_name);
+
+  const [state, patch] = React.useReducer(reducer, {
+    status: "init",
+    pr: null,
+  });
+
+  switch (state.status) {
+    case "done":
+      return props.children;
+
+    case "revise":
+      return (
+        <Await
+          function={run_revise}
+          fallback={
+            <Ink.Text color={colors.yellow}>
+              Synchronizing local commit metadata with remote branch on Github…
+            </Ink.Text>
+          }
+        />
+      );
+
+    case "prompt":
+      return (
+        <YesNoPrompt
+          message={
+            <Ink.Box flexDirection="column">
+              <FormatText
+                wrapper={<Ink.Text color={colors.yellow} />}
+                message="{branch_name} exists on Github and was not generated with {git_stack}."
+                values={{
+                  branch_name: <Brackets>{branch_name}</Brackets>,
+                  git_stack: <Command>git stack</Command>,
+                }}
+              />
+              <Ink.Text> </Ink.Text>
+              <FormatText
+                message="  {url}"
+                values={{
+                  url: <Url>{state.pr?.url}</Url>,
+                }}
+              />
+              <Ink.Text> </Ink.Text>
+              <FormatText
+                wrapper={<Ink.Text color={colors.yellow} />}
+                message="In order to synchronize we need to rename your local branch, would you like to proceed?"
+              />
+            </Ink.Box>
+          }
+          onYes={async () => {
+            patch({ status: "revise" });
+          }}
+          onNo={async () => {
+            actions.exit(0);
+          }}
+        />
+      );
+
+    default:
+      return (
+        <Await
+          function={run}
+          fallback={
+            <Ink.Text color={colors.yellow}>
+              Checking for existing PR on Github…
+            </Ink.Text>
+          }
+        />
+      );
+  }
+
+  async function run() {
+    const actions = Store.getState().actions;
+    const branch_name = Store.getState().branch_name;
+    const commit_range = Store.getState().commit_range;
+
+    invariant(branch_name, "branch_name must exist");
+    invariant(commit_range, "branch_name must exist");
+
+    try {
+      let has_existing_metadata = false;
+      for (const commit of commit_range.commit_list) {
+        if (commit.branch_id) {
+          has_existing_metadata = true;
+          break;
+        }
+      }
+
+      if (!has_existing_metadata) {
+        // check for pr with matching branch name to initialize group
+        const pr = await github.pr_status(branch_name);
+        if (pr) {
+          return patch({ status: "prompt", pr });
+        }
+      }
+
+      patch({ status: "done" });
+    } catch (err) {
+      actions.error("Must be run from within a git repository.");
+
+      if (err instanceof Error) {
+        if (actions.isDebug()) {
+          actions.error(err.message);
+        }
+      }
+
+      actions.exit(9);
+    }
+  }
+
+  async function run_revise() {
+    const actions = Store.getState().actions;
+    const master_branch = Store.getState().master_branch;
+    const branch_name = Store.getState().branch_name;
+    const commit_range = cloneDeep(Store.getState().commit_range);
+
+    invariant(branch_name, "branch_name must exist");
+    invariant(commit_range, "branch_name must exist");
+
+    for (const group of commit_range.group_list) {
+      group.id = branch_name;
+      group.title = state.pr?.title || "-";
+    }
+
+    // get latest merge_base relative to local master
+    const rebase_group_index = 0;
+
+    const rebase_merge_base = (
+      await cli(`git merge-base HEAD ${master_branch}`)
+    ).stdout;
+
+    await GitReviseTodo.execute({
+      rebase_group_index,
+      rebase_merge_base,
+      commit_range,
+    });
+
+    const new_branch_name = `${branch_name}-sync`;
+    await cli(`git checkout -b ${new_branch_name}`);
+
+    await cli(`git branch -D ${branch_name}`);
+
+    const commit_range_new = await CommitMetadata.range();
+
+    actions.set((state) => {
+      state.branch_name = new_branch_name;
+      state.commit_range = commit_range_new;
+    });
+
+    patch({ status: "done" });
+  }
+}

package/src/app/DirtyCheck.tsx

@@ -68,17 +68,17 @@ export function DirtyCheck(props: Props) {
     default:
       return (
         <Await
+          function={run}
           fallback={
             <Ink.Text color={colors.yellow}>
               Ensuring <Command>git status --porcelain</Command>…
             </Ink.Text>
           }
-          function={rebase_check}
         />
       );
   }
 
-  async function rebase_check() {
+  async function run() {
     const actions = Store.getState().actions;
 
     try {
@@ -95,7 +95,7 @@ export function DirtyCheck(props: Props) {
         }
       }
 
-      actions.exit(9);
+      actions.exit(12);
     }
   }
 }

package/src/app/FormatText.tsx

@@ -5,7 +5,7 @@ import { FormattedMessage } from "react-intl";
 
 type Props = {
   message: string;
-  values: React.ComponentProps<typeof FormattedMessage>["values"];
+  values?: React.ComponentProps<typeof FormattedMessage>["values"];
   wrapper?: React.ReactNode;
 };
 

package/src/app/GatherMetadata.tsx

@@ -20,13 +20,13 @@ export function GatherMetadata(props: Props) {
   );
 
   return (
-    <Await fallback={fallback} function={gather_metadata}>
+    <Await fallback={fallback} function={run}>
       {props.children}
     </Await>
   );
 }
 
-async function gather_metadata() {
+async function run() {
   const actions = Store.getState().actions;
   const argv = Store.getState().argv;
 

package/src/app/LocalCommitStatus.tsx

@@ -28,7 +28,7 @@ export function LocalCommitStatus(props: Props) {
   }
 
   return (
-    <Await fallback={fallback} function={gather_metadata}>
+    <Await fallback={fallback} function={run}>
       {props.children}
     </Await>
   );
@@ -41,12 +41,11 @@ async function mock_metadata() {
 
   Store.setState((state) => {
     Object.assign(state, deserialized);
-
     state.step = "status";
   });
 }
 
-async function gather_metadata() {
+async function run() {
   const actions = Store.getState().actions;
 
   try {

package/src/app/LocalMergeRebase.tsx

@@ -1,193 +1,7 @@
 import * as React from "react";
 
-import fs from "node:fs";
-
-import * as Ink from "ink-cjs";
-
-import { Await } from "~/app/Await";
-import { Brackets } from "~/app/Brackets";
-import { FormatText } from "~/app/FormatText";
-import { Parens } from "~/app/Parens";
-import { Store } from "~/app/Store";
-import * as CommitMetadata from "~/core/CommitMetadata";
-import { cli } from "~/core/cli";
-import { colors } from "~/core/colors";
-import { invariant } from "~/core/invariant";
-import { short_id } from "~/core/short_id";
+import { Rebase } from "~/commands/Rebase";
 
 export function LocalMergeRebase() {
-  return (
-    <Await
-      fallback={<Ink.Text color={colors.yellow}>Rebasing commits…</Ink.Text>}
-      function={run}
-    />
-  );
-}
-
-async function run() {
-  const state = Store.getState();
-  const actions = state.actions;
-  const branch_name = state.branch_name;
-  const commit_range = state.commit_range;
-  const master_branch = state.master_branch;
-  const cwd = state.cwd;
-  const repo_root = state.repo_root;
-
-  invariant(branch_name, "branch_name must exist");
-  invariant(commit_range, "commit_range must exist");
-  invariant(repo_root, "repo_root must exist");
-
-  // always listen for SIGINT event and restore git state
-  process.once("SIGINT", handle_exit);
-
-  const temp_branch_name = `${branch_name}_${short_id()}`;
-
-  try {
-    // actions.debug(`commit_range=${JSON.stringify(commit_range, null, 2)}`);
-
-    // must perform rebase from repo root for applying git patch
-    process.chdir(repo_root);
-    await cli(`pwd`);
-
-    // update local master to match remote
-    await cli(
-      `git fetch --no-tags -v origin ${master_branch}:${master_branch}`
-    );
-
-    const master_sha = (await cli(`git rev-parse ${master_branch}`)).stdout;
-    const rebase_merge_base = master_sha;
-
-    // create temporary branch based on merge base
-    await cli(`git checkout -b ${temp_branch_name} ${rebase_merge_base}`);
-
-    const picked_commit_list = [];
-
-    for (let i = 0; i < commit_range.commit_list.length; i++) {
-      const commit = commit_range.commit_list[i];
-      const commit_pr = commit_range.pr_lookup[commit.branch_id || ""];
-
-      // drop commits that are in groups of merged PRs
-      const merged_pr = commit_pr?.state === "MERGED";
-
-      if (merged_pr) {
-        if (actions.isDebug()) {
-          actions.output(
-            <FormatText
-              wrapper={<Ink.Text color={colors.yellow} wrap="truncate-end" />}
-              message="Dropping {commit_message} {pr_status}"
-              values={{
-                commit_message: <Brackets>{commit.subject_line}</Brackets>,
-                pr_status: <Parens>MERGED</Parens>,
-              }}
-            />
-          );
-        }
-
-        continue;
-      }
-
-      if (actions.isDebug()) {
-        actions.output(
-          <FormatText
-            wrapper={<Ink.Text color={colors.yellow} wrap="truncate-end" />}
-            message="Picking {commit_message}"
-            values={{
-              commit_message: <Brackets>{commit.subject_line}</Brackets>,
-            }}
-          />
-        );
-      }
-
-      picked_commit_list.push(commit);
-    }
-
-    if (picked_commit_list.length > 0) {
-      // ensure clean base to avoid conflicts when applying patch
-      await cli(`git clean -fd`);
-
-      // create list of sha for cherry-pick
-      const sha_list = picked_commit_list.map((commit) => commit.sha).join(" ");
-
-      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
-    await cli(`git branch -f ${branch_name} ${temp_branch_name}`);
-
-    restore_git();
-
-    const next_commit_range = await CommitMetadata.range();
-
-    actions.set((state) => {
-      state.commit_range = next_commit_range;
-      state.step = "status";
-    });
-  } catch (err) {
-    actions.error("Unable to rebase.");
-
-    if (err instanceof Error) {
-      if (actions.isDebug()) {
-        actions.error(err.message);
-      }
-    }
-
-    handle_exit();
-  }
-
-  // cleanup git operations if cancelled during manual rebase
-  function restore_git() {
-    // signint handler MUST run synchronously
-    // trying to use `await cli(...)` here will silently fail since
-    // 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);
-    cli.sync(`git clean -df`, spawn_options);
-
-    // always put self back in original branch
-    cli.sync(`git checkout ${branch_name}`, spawn_options);
-
-    // ...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);
-    }
-    cli.sync(`pwd`, spawn_options);
-  }
-
-  function handle_exit() {
-    actions.output(
-      <Ink.Text color={colors.yellow}>
-        Restoring <Brackets>{branch_name}</Brackets>…
-      </Ink.Text>
-    );
-
-    restore_git();
-
-    actions.output(
-      <Ink.Text color={colors.yellow}>
-        Restored <Brackets>{branch_name}</Brackets>.
-      </Ink.Text>
-    );
-
-    actions.exit(6);
-  }
+  return <Rebase />;
 }
-
-const PATCH_FILE = "git-stack-cli-patch.patch";

package/src/app/ManualRebase.tsx

@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 
 import * as Ink from "ink-cjs";
+import cloneDeep from "lodash/cloneDeep";
 
 import { Await } from "~/app/Await";
 import { Brackets } from "~/app/Brackets";
@@ -34,18 +35,37 @@ async function run() {
   const actions = state.actions;
   const argv = state.argv;
   const branch_name = state.branch_name;
+  const original_commit_range = cloneDeep(state.commit_range);
   const commit_map = state.commit_map;
   const master_branch = state.master_branch;
   const cwd = state.cwd;
   const repo_root = state.repo_root;
 
   invariant(branch_name, "branch_name must exist");
+  invariant(original_commit_range, "original_commit_range must exist");
   invariant(commit_map, "commit_map must exist");
   invariant(repo_root, "repo_root must exist");
 
   // always listen for SIGINT event and restore git state
   process.once("SIGINT", handle_exit);
 
+  // get latest merge_base relative to local master
+  const merge_base = (await cli(`git merge-base HEAD ${master_branch}`)).stdout;
+
+  // immediately paint all commit to preserve selected commit ranges
+  original_commit_range.group_list.reverse();
+  for (const commit of original_commit_range.commit_list) {
+    const group_from_map = commit_map[commit.sha];
+    commit.branch_id = group_from_map.id;
+    commit.title = group_from_map.title;
+  }
+
+  await GitReviseTodo.execute({
+    rebase_group_index: 0,
+    rebase_merge_base: merge_base,
+    commit_range: original_commit_range,
+  });
+
   let DEFAULT_PR_BODY = "";
   if (state.pr_template_body) {
     DEFAULT_PR_BODY = state.pr_template_body;
@@ -58,9 +78,6 @@ async function run() {
   // reverse commit list so that we can cherry-pick in order
   commit_range.group_list.reverse();
 
-  // get latest merge_base relative to local master
-  const merge_base = (await cli(`git merge-base HEAD ${master_branch}`)).stdout;
-
   let rebase_merge_base = merge_base;
   let rebase_group_index = 0;
 
@@ -150,19 +167,11 @@ async function run() {
     // create temporary branch
     await cli(`git checkout -b ${temp_branch_name}`);
 
-    const git_revise_todo = GitReviseTodo({ rebase_group_index, commit_range });
-
-    // execute cli with temporary git sequence editor script
-    // revise from merge base to pick correct commits
-    await cli(
-      [
-        `GIT_EDITOR="${tmp_git_sequence_editor_path}"`,
-        `GIT_REVISE_TODO="${git_revise_todo}"`,
-        `git`,
-        `revise --edit -i ${rebase_merge_base}`,
-      ],
-      { stdio: ["ignore", "ignore", "ignore"] }
-    );
+    await GitReviseTodo.execute({
+      rebase_group_index,
+      rebase_merge_base,
+      commit_range,
+    });
 
     // early return since we do not need to sync
     if (!argv.sync) {

package/src/app/RebaseCheck.tsx

@@ -57,17 +57,17 @@ export function RebaseCheck(props: Props) {
     default:
       return (
         <Await
+          function={run}
           fallback={
             <Ink.Text color={colors.yellow}>
               Checking for <Command>git rebase</Command>…
             </Ink.Text>
           }
-          function={rebase_check}
         />
       );
   }
 
-  async function rebase_check() {
+  async function run() {
     const actions = Store.getState().actions;
 
     try {
@@ -88,7 +88,7 @@ export function RebaseCheck(props: Props) {
         }
       }
 
-      actions.exit(9);
+      actions.exit(13);
     }
   }
 }

package/src/app/SelectCommitRanges.tsx

@@ -9,8 +9,8 @@ import { Parens } from "~/app/Parens";
 import { Store } from "~/app/Store";
 import { TextInput } from "~/app/TextInput";
 import { colors } from "~/core/colors";
+import { gs_short_id } from "~/core/gs_short_id";
 import { invariant } from "~/core/invariant";
-import { short_id } from "~/core/short_id";
 import { wrap_index } from "~/core/wrap_index";
 
 import type { State } from "~/app/Store";
@@ -388,7 +388,7 @@ function SelectCommitRangesInternal(props: Props) {
   );
 
   function submit_group_input(title: string) {
-    const id = `gs-${short_id()}`;
+    const id = gs_short_id();
 
     actions.output(
       <FormatText