git-stack-cli 1.0.1 → 1.0.3

package/src/app/ManualRebase.tsx

@@ -0,0 +1,308 @@
+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 { Store } from "~/app/Store";
+import * as CommitMetadata from "~/core/CommitMetadata";
+import * as Metadata from "~/core/Metadata";
+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 { short_id } from "~/core/short_id";
+
+type Props = {
+  skipSync?: boolean;
+};
+
+export function ManualRebase(props: Props) {
+  return (
+    <Await
+      fallback={<Ink.Text color={colors.yellow}>Rebasing commits...</Ink.Text>}
+      function={() => run(props)}
+    />
+  );
+}
+
+async function run(props: Props) {
+  const state = Store.getState();
+  const actions = state.actions;
+  const argv = state.argv;
+  const branch_name = state.branch_name;
+  const merge_base = state.merge_base;
+  const commit_map = state.commit_map;
+  const cwd = state.cwd;
+  const repo_root = state.repo_root;
+
+  invariant(argv, "argv must exist");
+  invariant(branch_name, "branch_name must exist");
+  invariant(merge_base, "merge_base must exist");
+  invariant(commit_map, "commit_map must exist");
+  invariant(cwd, "cwd 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()}`;
+
+  const commit_range = await CommitMetadata.range(commit_map);
+
+  // reverse commit list so that we can cherry-pick in order
+  commit_range.group_list.reverse();
+
+  let rebase_merge_base = merge_base;
+  let rebase_group_index = 0;
+
+  for (let i = 0; i < commit_range.group_list.length; i++) {
+    const group = commit_range.group_list[i];
+
+    if (!group.dirty) {
+      continue;
+    }
+
+    if (i > 0) {
+      const last_group = commit_range.group_list[i - 1];
+      const last_commit = last_group.commits[last_group.commits.length - 1];
+      rebase_merge_base = last_commit.sha;
+      rebase_group_index = i;
+    }
+
+    break;
+  }
+
+  try {
+    // must perform rebase from repo root for applying git patch
+    process.chdir(repo_root);
+    await cli(`pwd`);
+
+    // create temporary branch based on merge base
+    await cli(`git checkout -b ${temp_branch_name} ${rebase_merge_base}`);
+
+    const pr_url_list = commit_range.group_list.map(get_group_url);
+
+    for (let i = rebase_group_index; i < commit_range.group_list.length; i++) {
+      const group = commit_range.group_list[i];
+
+      invariant(group.base, "group.base must exist");
+
+      actions.output(
+        <FormatText
+          wrapper={<Ink.Text color={colors.yellow} wrap="truncate-end" />}
+          message="Rebasing {group}…"
+          values={{
+            group: (
+              <Brackets>{group.pr?.title || group.title || group.id}</Brackets>
+            ),
+          }}
+        />
+      );
+
+      const selected_url = get_group_url(group);
+
+      // cherry-pick and amend commits one by one
+      for (const commit of group.commits) {
+        // ensure clean base to avoid conflicts when applying patch
+        await cli(`git clean -fd`);
+
+        // create, apply and cleanup patch
+        await cli(`git format-patch -1 ${commit.sha} --stdout > ${PATCH_FILE}`);
+        await cli(`git apply ${PATCH_FILE}`);
+        await cli(`rm ${PATCH_FILE}`);
+
+        // add all changes to stage
+        await cli(`git add --all`);
+
+        const new_message = await Metadata.write(commit.full_message, group.id);
+        const git_commit_comand = [`git commit -m "${new_message}"`];
+
+        if (argv.verify === false) {
+          git_commit_comand.push("--no-verify");
+        }
+
+        await cli(git_commit_comand);
+      }
+
+      actions.output(
+        <FormatText
+          wrapper={<Ink.Text color={colors.yellow} wrap="truncate-end" />}
+          message="Syncing {group}…"
+          values={{
+            group: (
+              <Brackets>{group.pr?.title || group.title || group.id}</Brackets>
+            ),
+          }}
+        />
+      );
+
+      if (!props.skipSync) {
+        // push to origin since github requires commit shas to line up perfectly
+        const git_push_command = [`git push -f origin HEAD:${group.id}`];
+
+        if (argv.verify === false) {
+          git_push_command.push("--no-verify");
+        }
+
+        await cli(git_push_command);
+
+        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,
+            }),
+          });
+        } else {
+          // delete local group branch if leftover
+          await cli(`git branch -D ${group.id}`, { ignoreExitCode: true });
+
+          // move to temporary branch for creating pr
+          await cli(`git checkout -b ${group.id}`);
+
+          // create pr in github
+          const pr_url = await github.pr_create({
+            branch: group.id,
+            base: group.base,
+            title: group.title,
+            body: "",
+          });
+
+          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;
+            }
+          }
+
+          // move back to temp branch
+          await cli(`git checkout ${temp_branch_name}`);
+        }
+      }
+    }
+
+    // finally, ensure all prs have the updated stack table from updated pr_url_list
+    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];
+
+      invariant(group.base, "group.base must exist");
+
+      const body = group.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,
+        });
+      }
+    }
+
+    // after all commits have been cherry-picked and amended
+    // move the branch pointer to the newly created temporary branch
+    // now we are in locally in sync with github and on the original branch
+    await cli(`git branch -f ${branch_name} ${temp_branch_name}`);
+
+    restore_git();
+
+    actions.set((state) => {
+      state.step = "post-rebase-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
+    invariant(cwd, "cwd must exist");
+    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(5);
+  }
+}
+
+type CommitMetadataGroup = CommitMetadata.CommitRange["group_list"][number];
+const get_group_url = (group: CommitMetadataGroup) => group.pr?.url || group.id;
+
+const PATCH_FILE = "git-stack-cli-patch.patch";

package/src/app/MultiSelect.tsx

@@ -0,0 +1,246 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { clamp } from "~/core/clamp";
+import { colors } from "~/core/colors";
+import { is_finite_value } from "~/core/is_finite_value";
+import { wrap_index } from "~/core/wrap_index";
+
+type Props<T> = {
+  items: Array<Item<T>>;
+  onSelect(args: SelectArgs<T>): void;
+  disabled?: boolean;
+  maxWidth?: number;
+};
+
+type Item<T> = {
+  label: string;
+  value: T;
+  selected?: ItemRowProps["selected"];
+  disabled?: ItemRowProps["disabled"];
+};
+
+type SelectArgs<T> = {
+  item: T;
+  selected: boolean;
+  state: Array<T>;
+};
+
+export function MultiSelect<T>(props: Props<T>) {
+  const [selected_set, select] = React.useReducer(
+    (state: Set<number>, value: number) => {
+      const next = new Set(state);
+
+      if (next.has(value)) {
+        next.delete(value);
+      } else {
+        next.add(value);
+      }
+
+      return next;
+    },
+    new Set<number>(),
+    (set) => {
+      props.items.forEach((item, i) => {
+        if (item.selected) {
+          set.add(i);
+        }
+      });
+
+      return set;
+    }
+  );
+
+  // clamp index to keep in item range
+  const [index, set_index] = React.useReducer(
+    (_: unknown, value: number) => {
+      return clamp(value, 0, props.items.length - 1);
+    },
+    0,
+    function find_initial_index() {
+      let last_enabled;
+
+      for (let i = props.items.length - 1; i >= 0; i--) {
+        const item = props.items[i];
+
+        if (!item.disabled) {
+          last_enabled = i;
+        }
+
+        if (!item.selected && !item.disabled) {
+          return i;
+        }
+      }
+
+      if (is_finite_value(last_enabled)) {
+        return last_enabled;
+      }
+
+      return 0;
+    }
+  );
+
+  const selectRef = React.useRef(false);
+
+  React.useEffect(() => {
+    if (!selectRef.current) {
+      // console.debug("[MultiSelect]", "skip onSelect before selectRef");
+      return;
+    }
+
+    const item = props.items[index].value;
+    const selected_list = Array.from(selected_set);
+    const selected = selected_set.has(index);
+    const state = selected_list.map((index) => props.items[index].value);
+
+    // console.debug({ item, selected, state });
+    props.onSelect({ item, selected, state });
+  }, [selected_set]);
+
+  Ink.useInput((input, key) => {
+    if (props.disabled) {
+      // console.debug("[MultiSelect] disabled, ignoring input");
+      return;
+    }
+
+    const space = input === " ";
+
+    if (key.return || space) {
+      selectRef.current = true;
+      const item = props.items[index];
+      if (!item.disabled) {
+        return select(index);
+      }
+    }
+
+    if (key.upArrow) {
+      let check = index;
+      for (let i = 0; i < props.items.length; i++) {
+        check = wrap_index(check - 1, props.items);
+        // console.debug("up", { check, i, index });
+
+        const item = props.items[check];
+        if (!item.disabled) {
+          return set_index(check);
+        }
+      }
+    }
+
+    if (key.downArrow) {
+      let check = index;
+      for (let i = 0; i < props.items.length; i++) {
+        check = wrap_index(check + 1, props.items);
+        // console.debug("down", { check, i, index });
+
+        const item = props.items[check];
+        if (!item.disabled) {
+          return set_index(check);
+        }
+      }
+    }
+  });
+
+  return (
+    <Ink.Box flexDirection="column">
+      {props.items.map((item, i) => {
+        const active = i === index;
+        const selected = selected_set.has(i);
+        const disabled = item.disabled || false;
+
+        return (
+          <ItemRow
+            key={i}
+            label={item.label}
+            active={active}
+            selected={selected}
+            disabled={disabled}
+            maxWidth={props.maxWidth}
+          />
+        );
+      })}
+    </Ink.Box>
+  );
+}
+
+type ItemRowProps = {
+  label: string;
+  active: boolean;
+  selected: boolean;
+  disabled: boolean;
+  maxWidth?: number;
+};
+
+function ItemRow(props: ItemRowProps) {
+  let color;
+  let bold;
+  let underline;
+  let dimColor;
+
+  if (props.active) {
+    color = colors.blue;
+    underline = true;
+  }
+
+  if (props.selected) {
+    // color = "";
+    bold = true;
+  }
+
+  if (props.disabled) {
+    color = "";
+    bold = false;
+    underline = false;
+    dimColor = true;
+  }
+
+  return (
+    <Ink.Box flexDirection="row" gap={1}>
+      <Radio selected={props.selected} disabled={props.disabled} />
+
+      <Ink.Box width={props.maxWidth}>
+        <Ink.Text
+          bold={bold}
+          underline={underline}
+          color={color}
+          dimColor={dimColor}
+          wrap="truncate-end"
+        >
+          {props.label}
+        </Ink.Text>
+      </Ink.Box>
+    </Ink.Box>
+  );
+}
+
+type RadioProps = {
+  selected: ItemRowProps["selected"];
+  disabled: ItemRowProps["disabled"];
+};
+
+function Radio(props: RadioProps) {
+  let display;
+  let color;
+  let dimColor;
+
+  if (props.selected) {
+    // display = "✓";
+    display = "◉";
+    color = colors.green;
+  } else {
+    // display = " ";
+    display = "◯";
+    color = "";
+  }
+
+  if (props.disabled) {
+    color = colors.gray;
+    dimColor = true;
+  }
+
+  return (
+    <Ink.Text bold={props.selected} color={color} dimColor={dimColor}>
+      {display}
+    </Ink.Text>
+  );
+}

package/src/app/Output.tsx

@@ -0,0 +1,37 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { Store } from "~/app/Store";
+
+export function Output() {
+  const output = Store.useState((state) => state.output);
+  const pending_output = Store.useState((state) => state.pending_output);
+  const pending_output_items = Object.values(pending_output);
+
+  return (
+    <React.Fragment>
+      <Ink.Static items={output}>
+        {(node, i) => {
+          return <Ink.Box key={i}>{node}</Ink.Box>;
+        }}
+      </Ink.Static>
+
+      {pending_output_items.map((node_list, i) => {
+        return (
+          <Ink.Box key={i}>
+            <Ink.Text>
+              {node_list.map((text, j) => {
+                return (
+                  <React.Fragment key={j}>
+                    <Ink.Text>{text}</Ink.Text>
+                  </React.Fragment>
+                );
+              })}
+            </Ink.Text>
+          </Ink.Box>
+        );
+      })}
+    </React.Fragment>
+  );
+}

package/src/app/Parens.tsx

@@ -0,0 +1,21 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { colors } from "~/core/colors";
+
+type Props = {
+  children: React.ReactNode;
+};
+
+export function Parens(props: Props) {
+  const color = colors.blue;
+
+  return (
+    <Ink.Text>
+      <Ink.Text color={color}>(</Ink.Text>
+      {props.children}
+      <Ink.Text color={color}>)</Ink.Text>
+    </Ink.Text>
+  );
+}

package/src/app/PostRebaseStatus.tsx

@@ -0,0 +1,33 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { Await } from "~/app/Await";
+import { StatusTable } from "~/app/StatusTable";
+import { Store } from "~/app/Store";
+import * as CommitMetadata from "~/core/CommitMetadata";
+import { invariant } from "~/core/invariant";
+
+export function PostRebaseStatus() {
+  const argv = Store.useState((state) => state.argv);
+  invariant(argv, "argv must exist");
+
+  return <Await fallback={null} function={run} />;
+}
+
+async function run() {
+  const actions = Store.getState().actions;
+
+  // reset github pr cache before refreshing via commit range below
+  actions.reset_pr();
+
+  const commit_range = await CommitMetadata.range();
+
+  actions.set((state) => {
+    state.commit_range = commit_range;
+  });
+
+  actions.output(<StatusTable />);
+
+  actions.output(<Ink.Text>✅ Everything up to date.</Ink.Text>);
+}

package/src/app/PreLocalMergeRebase.tsx

@@ -0,0 +1,31 @@
+import * as React from "react";
+
+import { Store } from "~/app/Store";
+import { YesNoPrompt } from "~/app/YesNoPrompt";
+import { invariant } from "~/core/invariant";
+
+export function PreLocalMergeRebase() {
+  const actions = Store.useActions();
+  const argv = Store.useState((state) => state.argv);
+  invariant(argv, "argv must exist");
+
+  React.useEffect(() => {
+    if (argv.force) {
+      Store.setState((state) => {
+        state.step = "local-merge-rebase";
+      });
+    }
+  }, [argv]);
+
+  return (
+    <YesNoPrompt
+      message="Local branch needs to be rebased, would you like to rebase to update your local branch?"
+      onYes={() => {
+        actions.set((state) => {
+          state.step = "local-merge-rebase";
+        });
+      }}
+      onNo={() => actions.exit(0)}
+    />
+  );
+}

package/src/app/PreSelectCommitRanges.tsx

@@ -0,0 +1,31 @@
+import * as React from "react";
+
+import { Store } from "~/app/Store";
+import { YesNoPrompt } from "~/app/YesNoPrompt";
+import { invariant } from "~/core/invariant";
+
+export function PreSelectCommitRanges() {
+  const actions = Store.useActions();
+  const argv = Store.useState((state) => state.argv);
+  invariant(argv, "argv must exist");
+
+  React.useEffect(() => {
+    if (argv.force) {
+      Store.setState((state) => {
+        state.step = "select-commit-ranges";
+      });
+    }
+  }, [argv]);
+
+  return (
+    <YesNoPrompt
+      message="Some commits are new or outdated, would you like to select new commit ranges?"
+      onYes={() => {
+        actions.set((state) => {
+          state.step = "select-commit-ranges";
+        });
+      }}
+      onNo={() => actions.exit(0)}
+    />
+  );
+}