git-stack-cli 1.0.2 → 1.0.4

package/src/app/Providers.tsx

@@ -0,0 +1,11 @@
+import * as React from "react";
+
+import { IntlProvider } from "react-intl";
+
+type Props = {
+  children: React.ReactNode;
+};
+
+export function Providers(props: Props) {
+  return <IntlProvider locale="en">{props.children}</IntlProvider>;
+}

package/src/app/RebaseCheck.tsx

@@ -0,0 +1,96 @@
+import * as React from "react";
+
+import fs from "node:fs";
+import path from "node:path";
+
+import * as Ink from "ink-cjs";
+
+import { Await } from "~/app/Await";
+import { Store } from "~/app/Store";
+import { YesNoPrompt } from "~/app/YesNoPrompt";
+import { cli } from "~/core/cli";
+import { colors } from "~/core/colors";
+import { invariant } from "~/core/invariant";
+
+type Props = {
+  children: React.ReactNode;
+};
+
+type State = {
+  status: "init" | "prompt" | "done";
+};
+
+function reducer(state: State, patch: Partial<State>) {
+  return { ...state, ...patch };
+}
+
+export function RebaseCheck(props: Props) {
+  const actions = Store.useActions();
+  const argv = Store.useState((state) => state.argv);
+  invariant(argv, "argv must exist");
+
+  const [state, patch] = React.useReducer(reducer, {
+    status: "init",
+  });
+
+  switch (state.status) {
+    case "done":
+      return props.children;
+
+    case "prompt":
+      return (
+        <YesNoPrompt
+          message={
+            <Ink.Text color={colors.yellow}>
+              Rebase detected, would you like to abort it?
+            </Ink.Text>
+          }
+          onYes={async () => {
+            await cli(`git rebase --abort`);
+            patch({ status: "done" });
+          }}
+          onNo={async () => {
+            actions.exit(0);
+          }}
+        />
+      );
+
+    default:
+      return (
+        <Await
+          fallback={
+            <Ink.Text color={colors.yellow}>Checking for rebase...</Ink.Text>
+          }
+          function={rebase_check}
+        />
+      );
+  }
+
+  async function rebase_check() {
+    const actions = Store.getState().actions;
+    const argv = Store.getState().argv;
+
+    invariant(argv, "argv must exist");
+
+    try {
+      const repo_root = (await cli(`git rev-parse --absolute-git-dir`)).stdout;
+
+      let is_rebase = false;
+      is_rebase ||= fs.existsSync(path.join(repo_root, "rebase-apply"));
+      is_rebase ||= fs.existsSync(path.join(repo_root, "rebase-merge"));
+
+      const status = is_rebase ? "prompt" : "done";
+      patch({ status });
+    } 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);
+    }
+  }
+}

package/src/app/SelectCommitRanges.tsx

@@ -0,0 +1,372 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { Brackets } from "~/app/Brackets";
+import { FormatText } from "~/app/FormatText";
+import { MultiSelect } from "~/app/MultiSelect";
+import { Parens } from "~/app/Parens";
+import { Store } from "~/app/Store";
+import { TextInput } from "~/app/TextInput";
+import { colors } from "~/core/colors";
+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";
+
+export function SelectCommitRanges() {
+  const commit_range = Store.useState((state) => state.commit_range);
+
+  invariant(commit_range, "commit_range must exist");
+
+  return <SelectCommitRangesInternal commit_range={commit_range} />;
+}
+
+type Props = {
+  commit_range: CommitRange;
+};
+
+type CommitRange = NonNullable<State["commit_range"]>;
+type SimpleGroup = { id: string; title: string };
+
+function SelectCommitRangesInternal(props: Props) {
+  const actions = Store.useActions();
+
+  const [selected_group_id, set_selected_group_id] = React.useState(
+    props.commit_range.UNASSIGNED
+  );
+
+  const [group_input, set_group_input] = React.useState(false);
+
+  const [new_group_list, create_group] = React.useReducer(
+    (group_list: Array<SimpleGroup>, group: SimpleGroup) => {
+      return group_list.concat(group);
+    },
+    []
+  );
+
+  const [commit_map, update_commit_map] = React.useReducer(
+    (
+      map: Map<string, null | string>,
+      args: { key: string; value: null | string }
+    ) => {
+      map.set(args.key, args.value);
+
+      // console.debug("update_commit_map", map, args);
+      return new Map(map);
+    },
+    new Map(),
+    (map) => {
+      for (const commit of props.commit_range.commit_list) {
+        map.set(commit.sha, commit.branch_id);
+      }
+
+      return new Map(map);
+    }
+  );
+
+  const group_list: Array<SimpleGroup> = [];
+
+  // detect if there are unassigned commits
+  let unassigned_count = 0;
+  for (const [, group_id] of commit_map.entries()) {
+    if (group_id === null) {
+      // console.debug("unassigned commit detected", sha);
+      unassigned_count++;
+    }
+  }
+
+  group_list.push(...new_group_list);
+
+  const total_group_count =
+    new_group_list.length + props.commit_range.group_list.length;
+
+  for (const group of props.commit_range.group_list) {
+    if (group.pr?.state === "MERGED") continue;
+
+    if (group.id === props.commit_range.UNASSIGNED) {
+      // only include unassigned group when there are no other groups
+      if (total_group_count === 1) {
+        group_list.push({
+          id: group.id,
+          title: "Unassigned",
+        });
+      }
+
+      continue;
+    }
+
+    group_list.push({
+      id: group.id,
+      title: group.pr?.title || group.id,
+    });
+  }
+
+  let current_index = group_list.findIndex((g) => g.id === selected_group_id);
+  if (current_index === -1) {
+    current_index = 0;
+  }
+
+  Ink.useInput((input, key) => {
+    const inputLower = input.toLowerCase();
+
+    const hasUnassignedCommits = unassigned_count > 0;
+
+    if (!hasUnassignedCommits && inputLower === "s") {
+      actions.set((state) => {
+        state.commit_map = {};
+
+        for (const [sha, id] of commit_map.entries()) {
+          if (id) {
+            const group = group_list.find((g) => g.id === id);
+            // console.debug({ sha, id, group });
+            if (group) {
+              state.commit_map[sha] = group;
+            }
+          }
+        }
+
+        switch (inputLower) {
+          case "s":
+            state.step = "manual-rebase";
+            break;
+        }
+      });
+      return;
+    }
+
+    // only allow create when on unassigned group
+    if (hasUnassignedCommits && inputLower === "c") {
+      set_group_input(true);
+      return;
+    }
+
+    if (key.leftArrow) {
+      const new_index = wrap_index(current_index - 1, group_list);
+      const next_group = group_list[new_index];
+      return set_selected_group_id(next_group.id);
+    }
+
+    if (key.rightArrow) {
+      const new_index = wrap_index(current_index + 1, group_list);
+      const next_group = group_list[new_index];
+      return set_selected_group_id(next_group.id);
+    }
+  });
+
+  const group = group_list[current_index];
+
+  const items = props.commit_range.commit_list.map((commit) => {
+    const commit_metadata_id = commit_map.get(commit.sha);
+
+    const selected = commit_metadata_id !== null;
+
+    let disabled;
+
+    if (group.id === props.commit_range.UNASSIGNED) {
+      disabled = true;
+    } else {
+      disabled = Boolean(selected && commit_metadata_id !== group.id);
+    }
+
+    return {
+      label: commit.subject_line,
+      value: commit,
+      selected,
+      disabled,
+    };
+  });
+
+  items.reverse();
+
+  // <-  (2/4) #742 Title A ->
+
+  const left_arrow = `${SYMBOL.left} `;
+  const right_arrow = ` ${SYMBOL.right}`;
+  const group_position = `(${current_index + 1}/${group_list.length}) `;
+
+  const max_group_label_width = 80;
+  let group_title_width = max_group_label_width;
+  group_title_width -= group_position.length;
+  group_title_width -= left_arrow.length + right_arrow.length;
+  group_title_width = Math.min(group.title.length, group_title_width);
+
+  let max_item_width = max_group_label_width;
+  max_item_width -= left_arrow.length + right_arrow.length;
+
+  return (
+    <Ink.Box flexDirection="column">
+      <Ink.Box height={1} />
+
+      <MultiSelect
+        key={group.id}
+        items={items}
+        maxWidth={max_item_width}
+        disabled={group_input}
+        onSelect={(args) => {
+          // console.debug("onSelect", args);
+
+          const key = args.item.sha;
+
+          let value;
+          if (args.selected) {
+            value = group.id;
+          } else {
+            value = null;
+          }
+
+          update_commit_map({ key, value });
+        }}
+      />
+
+      <Ink.Box height={1} />
+
+      <Ink.Box width={max_group_label_width} flexDirection="row">
+        <Ink.Text>{left_arrow}</Ink.Text>
+        <Ink.Text>{group_position}</Ink.Text>
+
+        <Ink.Box width={group_title_width} justifyContent="center">
+          <Ink.Text wrap="truncate-end">{group.title}</Ink.Text>
+        </Ink.Box>
+
+        <Ink.Text>{right_arrow}</Ink.Text>
+      </Ink.Box>
+
+      <Ink.Box height={1} />
+
+      {unassigned_count > 0 ? (
+        <FormatText
+          wrapper={<Ink.Text color={colors.gray} />}
+          message="{count} unassigned commits, press {c} to {create} a new group"
+          values={{
+            count: (
+              <Ink.Text color={colors.yellow} bold>
+                {unassigned_count}
+              </Ink.Text>
+            ),
+            c: (
+              <Ink.Text bold color={colors.green}>
+                c
+              </Ink.Text>
+            ),
+            create: (
+              <Ink.Text bold color={colors.green}>
+                <Parens>c</Parens>reate
+              </Ink.Text>
+            ),
+          }}
+        />
+      ) : (
+        <React.Fragment>
+          <FormatText
+            wrapper={<Ink.Text />}
+            message="🎉 Done! Press {s} to {sync} the commits to Github"
+            values={{
+              s: (
+                <Ink.Text bold color={colors.green}>
+                  s
+                </Ink.Text>
+              ),
+              sync: (
+                <Ink.Text bold color={colors.green}>
+                  <Parens>s</Parens>ync
+                </Ink.Text>
+              ),
+            }}
+          />
+        </React.Fragment>
+      )}
+
+      {!group_input ? null : (
+        <React.Fragment>
+          <Ink.Box height={1} />
+
+          <FormatText
+            wrapper={<Ink.Text color={colors.gray} />}
+            message="Enter a title for the PR {note}"
+            values={{
+              note: (
+                <Parens>
+                  <FormatText
+                    message="press {enter} to submit"
+                    values={{
+                      enter: (
+                        <Ink.Text bold color={colors.green}>
+                          {SYMBOL.enter}
+                        </Ink.Text>
+                      ),
+                    }}
+                  />
+                </Parens>
+              ),
+            }}
+          />
+
+          <TextInput onSubmit={submit_group_input} />
+
+          <Ink.Box height={1} />
+        </React.Fragment>
+      )}
+
+      <Ink.Box>
+        <FormatText
+          wrapper={<Ink.Text color={colors.gray} />}
+          message="Press {left} and {right} to view PR groups"
+          values={{
+            left: (
+              <Ink.Text bold color={colors.green}>
+                {SYMBOL.left}
+              </Ink.Text>
+            ),
+            right: (
+              <Ink.Text bold color={colors.green}>
+                {SYMBOL.right}
+              </Ink.Text>
+            ),
+          }}
+        />
+      </Ink.Box>
+
+      <Ink.Box>
+        <FormatText
+          wrapper={<Ink.Text color={colors.gray} />}
+          message="Press {enter} to toggle commit selection"
+          values={{
+            enter: (
+              <Ink.Text bold color={colors.green}>
+                {SYMBOL.enter}
+              </Ink.Text>
+            ),
+          }}
+        />
+      </Ink.Box>
+    </Ink.Box>
+  );
+
+  function submit_group_input(title: string) {
+    const id = short_id();
+
+    actions.output(
+      <FormatText
+        wrapper={<Ink.Text dimColor />}
+        message="Created new group {group} {note}"
+        values={{
+          group: <Brackets>{title}</Brackets>,
+          note: <Parens>{id}</Parens>,
+        }}
+      />
+    );
+
+    // console.debug("submit_group_input", { title, id });
+    create_group({ id, title });
+    set_selected_group_id(id);
+    set_group_input(false);
+  }
+}
+
+const SYMBOL = {
+  left: "←",
+  right: "→",
+  enter: "Enter",
+};

package/src/app/Status.tsx

@@ -0,0 +1,82 @@
+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 { colors } from "~/core/colors";
+import { invariant } from "~/core/invariant";
+
+import type { Argv } from "~/command";
+
+export function Status() {
+  const argv = Store.useState((state) => state.argv);
+  invariant(argv, "argv must exist");
+
+  return <Await fallback={null} function={() => run({ argv })} />;
+}
+
+type Args = {
+  argv: Argv;
+};
+
+async function run(args: Args) {
+  const actions = Store.getState().actions;
+  const commit_range = Store.getState().commit_range;
+
+  invariant(commit_range, "commit_range must exist");
+
+  actions.output(<StatusTable />);
+
+  let needs_rebase = false;
+  let needs_update = false;
+
+  for (const group of commit_range.group_list) {
+    if (group.dirty) {
+      needs_update = true;
+    }
+
+    if (group.pr?.state === "MERGED") {
+      needs_rebase = true;
+    }
+  }
+
+  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 || ""];
+
+    if (commit.branch_id && !commit_pr) {
+      needs_rebase = true;
+    }
+  }
+
+  if (args.argv.check) {
+    actions.exit(0);
+  } else if (needs_rebase) {
+    Store.setState((state) => {
+      state.step = "pre-local-merge-rebase";
+    });
+  } else if (needs_update) {
+    Store.setState((state) => {
+      state.step = "pre-select-commit-ranges";
+    });
+  } else if (args.argv.force) {
+    Store.setState((state) => {
+      state.step = "select-commit-ranges";
+    });
+  } else {
+    actions.output(<Ink.Text>✅ Everything up to date.</Ink.Text>);
+    actions.output(
+      <Ink.Text color={colors.gray}>
+        <Ink.Text>Run with</Ink.Text>
+        <Ink.Text bold color={colors.yellow}>
+          {` --force `}
+        </Ink.Text>
+        <Ink.Text>to force update all pull requests.</Ink.Text>
+      </Ink.Text>
+    );
+
+    actions.exit(0);
+  }
+}

package/src/app/StatusTable.tsx

@@ -0,0 +1,155 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { Store } from "~/app/Store";
+import { Table } from "~/app/Table";
+import { Url } from "~/app/Url";
+import { assertNever } from "~/core/assertNever";
+import { colors } from "~/core/colors";
+import { invariant } from "~/core/invariant";
+
+import type { TableColumnProps } from "~/app/Table";
+
+export function StatusTable() {
+  const commit_range = Store.useState((state) => state.commit_range);
+
+  invariant(commit_range, "commit_range must exist");
+
+  const row_list = [];
+
+  for (const group of commit_range.group_list) {
+    const row: Row = {
+      count: "",
+      status: "NEW",
+      title: "",
+      url: "",
+    };
+
+    if (group.id === commit_range.UNASSIGNED) {
+      row.status = "NEW";
+      row.title = "Unassigned";
+      row.count = `0/${group.commits.length}`;
+      row.url = "";
+    } else {
+      if (group.dirty) {
+        row.status = "OUTDATED";
+      } else {
+        row.status = "SYNCED";
+      }
+
+      if (group.pr) {
+        if (group.pr.state === "MERGED") {
+          row.status = "MERGED";
+        }
+
+        row.title = group.pr.title;
+        row.count = `${group.pr.commits.length}/${group.commits.length}`;
+        row.url = group.pr.url;
+      } else {
+        row.title = group.title || group.id;
+        row.count = `0/${group.commits.length}`;
+      }
+    }
+
+    row_list.push(row);
+  }
+
+  return (
+    <Table
+      data={row_list}
+      fillColumn="title"
+      maxWidth={{
+        status: (v) => v + 2,
+      }}
+      columnGap={3}
+      columns={{
+        status: StatusColumn,
+        count: CountColumn,
+        title: TitleColumn,
+        url: UrlColumn,
+      }}
+    />
+  );
+}
+
+type Row = {
+  status: "NEW" | "OUTDATED" | "MERGED" | "SYNCED";
+  count: string;
+  title: string;
+  url: string;
+};
+
+function StatusColumn(props: TableColumnProps<Row>) {
+  const value = props.row[props.column];
+
+  return (
+    <Ink.Text
+      color={get_status_color(props.row)}
+      bold={get_status_bold(props.row)}
+    >
+      {get_status_icon(props.row)} {value}
+    </Ink.Text>
+  );
+}
+
+function CountColumn(props: TableColumnProps<Row>) {
+  const value = props.row[props.column];
+
+  return <Ink.Text dimColor>{value}</Ink.Text>;
+}
+
+function TitleColumn(props: TableColumnProps<Row>) {
+  const value = props.row[props.column];
+
+  return <Ink.Text wrap="truncate-end">{value}</Ink.Text>;
+}
+
+function UrlColumn(props: TableColumnProps<Row>) {
+  const value = props.row[props.column];
+
+  return <Url dimColor>{value}</Url>;
+}
+
+function get_status_icon(row: Row) {
+  switch (row.status) {
+    case "NEW":
+      return "⭑";
+    case "OUTDATED":
+      return "!";
+    case "MERGED":
+      return "↗";
+    case "SYNCED":
+      return "✔";
+    default:
+      assertNever(row.status);
+      return "?";
+    // unicode question mark in box
+  }
+}
+
+function get_status_color(row: Row) {
+  switch (row.status) {
+    case "NEW":
+      return colors.yellow;
+    case "OUTDATED":
+      return colors.red;
+    case "MERGED":
+      return colors.purple;
+    case "SYNCED":
+      return colors.green;
+    default:
+      assertNever(row.status);
+      return colors.gray;
+  }
+}
+
+function get_status_bold(row: Row) {
+  switch (row.status) {
+    case "NEW":
+    case "OUTDATED":
+      return true;
+    default:
+      return false;
+  }
+}