git-stack-cli 1.0.2 → 1.0.3

package/src/app/GatherMetadata.tsx

@@ -0,0 +1,145 @@
+import * as React from "react";
+
+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 { cli } from "~/core/cli";
+import { colors } from "~/core/colors";
+import { invariant } from "~/core/invariant";
+import { match_group } from "~/core/match_group";
+
+type Props = {
+  children: React.ReactNode;
+};
+
+export function GatherMetadata(props: Props) {
+  const argv = Store.useState((state) => state.argv);
+  invariant(argv, "argv must exist");
+
+  const fallback = (
+    <Ink.Text color={colors.yellow}>
+      Gathering local git information...
+    </Ink.Text>
+  );
+
+  return (
+    <Await fallback={fallback} function={gather_metadata}>
+      {props.children}
+    </Await>
+  );
+}
+
+async function gather_metadata() {
+  const actions = Store.getState().actions;
+  const argv = Store.getState().argv;
+
+  invariant(argv, "argv must exist");
+
+  try {
+    // default to master branch, fallback to main
+    let master_branch: string;
+
+    if (argv.branch) {
+      actions.debug(
+        <FormatText
+          message="Setting master branch to {branch}"
+          values={{
+            branch: <Brackets>{argv.branch}</Brackets>,
+          }}
+        />
+      );
+
+      master_branch = argv.branch;
+    } else {
+      const detect_master = await cli(
+        `git branch --list "${BRANCH.master}" --color=never`
+      );
+
+      if (detect_master.stdout !== "") {
+        master_branch = BRANCH.master;
+      } else {
+        actions.debug(
+          <FormatText
+            message="Could not find {master} branch, falling back to {main}"
+            values={{
+              master: <Brackets>{BRANCH.master}</Brackets>,
+              main: <Brackets>{BRANCH.main}</Brackets>,
+            }}
+          />
+        );
+
+        master_branch = BRANCH.main;
+      }
+    }
+
+    const branch_name = (await cli("git rev-parse --abbrev-ref HEAD")).stdout;
+
+    // handle detahed head state
+    if (branch_name === "HEAD") {
+      actions.error("Must run within a branch.");
+      actions.exit(0);
+      return;
+    }
+
+    // handle when there are no detected changes
+    if (branch_name === master_branch) {
+      actions.error("Must run within a branch.");
+      actions.exit(0);
+      return;
+    }
+
+    const head = (await cli("git rev-parse HEAD")).stdout;
+    const merge_base = (await cli(`git merge-base HEAD ${master_branch}`))
+      .stdout;
+
+    // handle when there are no detected changes
+    if (head === merge_base) {
+      actions.newline();
+      actions.output(
+        <Ink.Text color={colors.gray}>No changes detected.</Ink.Text>
+      );
+      actions.exit(0);
+      return;
+    }
+
+    // git@github.com:magus/git-multi-diff-playground.git
+    // https://github.com/magus/git-multi-diff-playground.git
+    const origin_url = (await cli(`git config --get remote.origin.url`)).stdout;
+    const repo_path = match_group(origin_url, RE.repo_path, "repo_path");
+
+    const repo_root = (await cli(`git rev-parse --show-toplevel`)).stdout;
+
+    Store.setState((state) => {
+      state.repo_path = repo_path;
+      state.repo_root = repo_root;
+      state.master_branch = master_branch;
+      state.head = head;
+      state.merge_base = merge_base;
+      state.branch_name = branch_name;
+    });
+  } catch (err) {
+    actions.error("Unable to gather git metadata.");
+
+    if (err instanceof Error) {
+      if (actions.isDebug()) {
+        actions.error(err.message);
+      }
+    }
+
+    actions.exit(7);
+  }
+}
+
+const RE = {
+  // git@github.com:magus/git-multi-diff-playground.git
+  // https://github.com/magus/git-multi-diff-playground.git
+  repo_path: /(?<repo_path>[^:^/]+\/[^/]+)\.git/,
+};
+
+const BRANCH = {
+  master: "master",
+  main: "main",
+};

package/src/app/GithubApiError.tsx

@@ -0,0 +1,78 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { Await } from "~/app/Await";
+import { Brackets } from "~/app/Brackets";
+import { Parens } from "~/app/Parens";
+import { Store } from "~/app/Store";
+import { cli } from "~/core/cli";
+import { colors } from "~/core/colors";
+import * as date from "~/core/date";
+import { invariant } from "~/core/invariant";
+
+export function GithubApiError() {
+  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;
+
+  const res = await cli(`gh api https://api.github.com/rate_limit`);
+
+  const res_json = JSON.parse(res.stdout);
+
+  const resources_graphql = res_json.resources.graphql;
+
+  const used = resources_graphql.used;
+  const limit = resources_graphql.limit;
+  const reset_date = new Date(resources_graphql.reset * 1000);
+
+  // calculate the time remaining in minutes
+  const now = new Date();
+  const diff_seconds = (reset_date.getTime() - now.getTime()) / 1000;
+  const diff_minutes = Math.round(diff_seconds / 60);
+
+  const reset_time = date.format_time(reset_date);
+
+  let time_until;
+  if (diff_minutes < 0) {
+    time_until = `${diff_seconds} seconds`;
+  } else {
+    time_until = `${diff_minutes} minutes`;
+  }
+
+  actions.output(
+    <Ink.Text dimColor>
+      <Ink.Text>{"Github "}</Ink.Text>
+
+      <Brackets>graphql</Brackets>
+
+      <Ink.Text>{" API rate limit "}</Ink.Text>
+
+      <Brackets>
+        <Ink.Text>{used}</Ink.Text>
+        <Ink.Text>/</Ink.Text>
+        <Ink.Text>{limit}</Ink.Text>
+      </Brackets>
+
+      <Ink.Text>{" will reset at "}</Ink.Text>
+
+      <Ink.Text bold color={colors.yellow}>
+        {reset_time}
+      </Ink.Text>
+
+      <Ink.Text> </Ink.Text>
+
+      <Parens>
+        <Ink.Text>{"in "}</Ink.Text>
+        <Ink.Text bold color={colors.yellow}>
+          {time_until}
+        </Ink.Text>
+      </Parens>
+    </Ink.Text>
+  );
+}

package/src/app/LocalCommitStatus.tsx

@@ -0,0 +1,70 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { Await } from "~/app/Await";
+import { Store } from "~/app/Store";
+import * as CommitMetadata from "~/core/CommitMetadata";
+import { colors } from "~/core/colors";
+import { invariant } from "~/core/invariant";
+import * as json from "~/core/json";
+
+type Props = {
+  children: React.ReactNode;
+};
+
+export function LocalCommitStatus(props: Props) {
+  const argv = Store.useState((state) => state.argv);
+  invariant(argv, "argv must exist");
+
+  const fallback = (
+    <Ink.Text color={colors.yellow}>Fetching PR status from Github...</Ink.Text>
+  );
+
+  if (argv["mock-metadata"]) {
+    return (
+      <Await fallback={fallback} function={mock_metadata}>
+        {props.children}
+      </Await>
+    );
+  }
+
+  return (
+    <Await fallback={fallback} function={gather_metadata}>
+      {props.children}
+    </Await>
+  );
+}
+
+async function mock_metadata() {
+  const module = await import("../__fixtures__/metadata");
+
+  const deserialized = json.deserialize(module.METADATA);
+
+  Store.setState((state) => {
+    Object.assign(state, deserialized);
+
+    state.step = "status";
+  });
+}
+
+async function gather_metadata() {
+  const actions = Store.getState().actions;
+
+  try {
+    const commit_range = await CommitMetadata.range();
+
+    Store.setState((state) => {
+      state.commit_range = commit_range;
+      state.step = "status";
+    });
+  } catch (err) {
+    actions.error("Unable to retrieve local commit status.");
+
+    if (err instanceof Error) {
+      if (actions.isDebug()) {
+        actions.error(err.message);
+      }
+    }
+  }
+}

package/src/app/LocalMergeRebase.tsx

@@ -0,0 +1,230 @@
+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 * as Metadata from "~/core/Metadata";
+import { cli } from "~/core/cli";
+import { colors } from "~/core/colors";
+import { invariant } from "~/core/invariant";
+import { short_id } from "~/core/short_id";
+
+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 argv = state.argv;
+  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(argv, "argv must exist");
+  invariant(branch_name, "branch_name must exist");
+  invariant(commit_range, "commit_range 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()}`;
+
+  try {
+    // must perform rebase from repo root for applying git patch
+    process.chdir(repo_root);
+    await cli(`pwd`);
+
+    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}`);
+
+    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;
+      }
+
+      // cherry-pick and amend commits one by one
+      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>,
+            }}
+          />
+        );
+      }
+
+      // 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`);
+
+      let new_message;
+      if (commit.branch_id) {
+        new_message = await Metadata.write(
+          commit.full_message,
+          commit.branch_id
+        );
+      } else {
+        new_message = commit.full_message;
+      }
+
+      const git_commit_comand = [`git commit -m "${new_message}"`];
+
+      if (argv.verify === false) {
+        git_commit_comand.push("--no-verify");
+      }
+
+      await cli(git_commit_comand);
+
+      if (commit.branch_id && !commit_pr) {
+        if (actions.isDebug()) {
+          actions.output(
+            <FormatText
+              wrapper={<Ink.Text color={colors.yellow} wrap="truncate-end" />}
+              message="Cleaning up unused group {group}"
+              values={{
+                group: <Brackets>{commit.branch_id}</Brackets>,
+              }}
+            />
+          );
+        }
+
+        // missing PR, clear branch id from commit
+        const new_message = await Metadata.remove(commit.full_message);
+        await cli(`git commit --amend -m "${new_message}"`);
+      }
+    }
+
+    // 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();
+
+    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
+    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(6);
+  }
+}
+
+const PATCH_FILE = "git-stack-cli-patch.patch";

package/src/app/LogTimestamp.tsx

@@ -0,0 +1,12 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+import { DateTime } from "luxon";
+
+export function LogTimestamp() {
+  return (
+    <Ink.Text dimColor>
+      {DateTime.now().toFormat("[yyyy-MM-dd HH:mm:ss.SSS] ")}
+    </Ink.Text>
+  );
+}

package/src/app/Main.tsx

@@ -0,0 +1,52 @@
+import * as React from "react";
+
+import { GithubApiError } from "~/app/GithubApiError";
+import { LocalMergeRebase } from "~/app/LocalMergeRebase";
+import { ManualRebase } from "~/app/ManualRebase";
+import { PostRebaseStatus } from "~/app/PostRebaseStatus";
+import { PreLocalMergeRebase } from "~/app/PreLocalMergeRebase";
+import { PreSelectCommitRanges } from "~/app/PreSelectCommitRanges";
+import { SelectCommitRanges } from "~/app/SelectCommitRanges";
+import { Status } from "~/app/Status";
+import { Store } from "~/app/Store";
+import { assertNever } from "~/core/assertNever";
+
+export function Main() {
+  const step = Store.useState((state) => state.step);
+
+  switch (step) {
+    case "github-api-error":
+      return <GithubApiError />;
+
+    case "loading":
+      return null;
+
+    case "status":
+      return <Status />;
+
+    case "local-merge-rebase":
+      return <LocalMergeRebase />;
+
+    case "pre-local-merge-rebase":
+      return <PreLocalMergeRebase />;
+
+    case "pre-select-commit-ranges":
+      return <PreSelectCommitRanges />;
+
+    case "select-commit-ranges":
+      return <SelectCommitRanges />;
+
+    case "manual-rebase":
+      return <ManualRebase />;
+
+    case "manual-rebase-no-sync":
+      return <ManualRebase skipSync />;
+
+    case "post-rebase-status":
+      return <PostRebaseStatus />;
+
+    default:
+      assertNever(step);
+      return null;
+  }
+}