git-stack-cli 2.9.2 → 2.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-stack-cli",
-  "version": "2.9.2",
+  "version": "2.9.4",
   "description": "",
   "author": "magus",
   "license": "MIT",

package/src/app/App.tsx

@@ -5,6 +5,7 @@ import { CherryPickCheck } from "~/app/CherryPickCheck";
 import { DependencyCheck } from "~/app/DependencyCheck";
 import { DetectInitialPR } from "~/app/DetectInitialPR";
 import { DirtyCheck } from "~/app/DirtyCheck";
+import { FetchPullRequests } from "~/app/FetchPullRequests";
 import { GatherMetadata } from "~/app/GatherMetadata";
 import { GithubApiError } from "~/app/GithubApiError";
 import { HandleCtrlCSigint } from "~/app/HandleCtrlCSigint";
@@ -100,9 +101,11 @@ function MaybeMain() {
       <DependencyCheck>
         <DirtyCheck>
           <GatherMetadata>
-            <LocalCommitStatus>
-              <Rebase />
-            </LocalCommitStatus>
+            <FetchPullRequests>
+              <LocalCommitStatus>
+                <Rebase />
+              </LocalCommitStatus>
+            </FetchPullRequests>
           </GatherMetadata>
         </DirtyCheck>
       </DependencyCheck>
@@ -117,11 +120,13 @@ function MaybeMain() {
         <DirtyCheck>
           <GatherMetadata>
             <RequireBranch>
-              <LocalCommitStatus>
-                <DetectInitialPR>
-                  <Main />
-                </DetectInitialPR>
-              </LocalCommitStatus>
+              <FetchPullRequests>
+                <LocalCommitStatus>
+                  <DetectInitialPR>
+                    <Main />
+                  </DetectInitialPR>
+                </LocalCommitStatus>
+              </FetchPullRequests>
             </RequireBranch>
           </GatherMetadata>
         </DirtyCheck>

package/src/app/DebugOutput.tsx

@@ -0,0 +1,40 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+import { DateTime } from "luxon";
+
+type Props = {
+  node: React.ReactNode;
+};
+
+export function DebugOutput(props: Props) {
+  const { stdout } = Ink.useStdout();
+  const available_width = stdout.columns;
+
+  const timestamp = DateTime.now().toFormat("yyyy-MM-dd HH:mm:ss.SSS");
+  const content_width = available_width - timestamp.length - 2;
+
+  const content = (function () {
+    switch (typeof props.node) {
+      case "boolean":
+      case "number":
+      case "string": {
+        return <Ink.Text dimColor>{String(props.node)}</Ink.Text>;
+      }
+      default:
+        return props.node;
+    }
+  })();
+
+  return (
+    <Ink.Box flexDirection="column">
+      <Ink.Box flexDirection="row" gap={1} width={available_width}>
+        <Ink.Box width={timestamp.length} flexDirection="column">
+          <Ink.Text dimColor>{timestamp}</Ink.Text>
+        </Ink.Box>
+
+        <Ink.Box width={content_width}>{content}</Ink.Box>
+      </Ink.Box>
+    </Ink.Box>
+  );
+}

package/src/app/FetchPullRequests.tsx

@@ -0,0 +1,40 @@
+import * as React from "react";
+
+import * as Ink from "ink-cjs";
+
+import { Await } from "~/app/Await";
+import { Store } from "~/app/Store";
+import { colors } from "~/core/colors";
+import * as github from "~/core/github";
+
+type Props = {
+  children: React.ReactNode;
+};
+
+export function FetchPullRequests(props: Props) {
+  const fallback = <Ink.Text color={colors.yellow}>Fetching pull requests…</Ink.Text>;
+
+  return (
+    <Await fallback={fallback} function={run}>
+      {props.children}
+    </Await>
+  );
+}
+
+async function run() {
+  const actions = Store.getState().actions;
+
+  try {
+    // gather all open prs in repo at once
+    // cheaper query to populate cache
+    await github.pr_list();
+  } catch (err) {
+    actions.error("Unable to fetch pull requests.");
+
+    if (err instanceof Error) {
+      actions.error(err.message);
+    }
+
+    actions.exit(24);
+  }
+}

package/src/app/GithubApiError.tsx

@@ -4,6 +4,7 @@ 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 { cli } from "~/core/cli";
@@ -51,34 +52,36 @@ async function run(props: Props) {
   }
 
   actions.output(
-    <Ink.Text>
-      <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>,
+    <FormatText
+      message="Github {graphql} API rate limit {ratio} will reset at {reset_time} {time_until}"
+      values={{
+        graphql: <Brackets>graphql</Brackets>,
+        ratio: (
+          <Brackets>
+            <FormatText message="{used}/{limit}" values={{ used, limit }} />
+          </Brackets>
+        ),
+        reset_time: (
+          <Ink.Text bold color={colors.yellow}>
+            {reset_time}
+          </Ink.Text>
+        ),
+        time_until: (
+          <Parens>
+            <FormatText
+              message="in {time_until}"
+              values={{
+                time_until: (
+                  <Ink.Text bold color={colors.yellow}>
+                    {time_until}
+                  </Ink.Text>
+                ),
+              }}
+            />
+          </Parens>
+        ),
+      }}
+    />,
   );
 
   if (props.exit) {

package/src/app/ManualRebase.tsx

@@ -47,6 +47,11 @@ async function run() {
     // get latest merge_base relative to local master
     const merge_base = (await cli(`git merge-base HEAD ${master_branch}`)).stdout;
 
+    // ensure merge_base is updated
+    actions.set((state) => {
+      state.merge_base = merge_base;
+    });
+
     // immediately paint all commit to preserve selected commit ranges
     let commit_range = await CommitMetadata.range(commit_map);
 
@@ -116,7 +121,7 @@ async function run() {
     if (argv.sync) {
       actions.set((state) => {
         state.step = "sync-github";
-        state.sync_github = { commit_range, rebase_group_index };
+        state.sync_github = { commit_range };
       });
     } else {
       actions.set((state) => {

package/src/app/Output.tsx

@@ -2,35 +2,26 @@ import * as React from "react";
 
 import * as Ink from "ink-cjs";
 
+import { DebugOutput } from "~/app/DebugOutput";
 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>;
+        {(entry) => {
+          const [id, node] = entry;
+          return <Ink.Box key={id}>{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>
-        );
+      {Object.entries(pending_output).map((entry) => {
+        const [id, content_list] = entry;
+        const content = content_list.join("");
+        return <DebugOutput key={id} node={content} />;
       })}
     </React.Fragment>
   );

package/src/app/Store.tsx

@@ -1,11 +1,13 @@
 import * as React from "react";
 
+import crypto from "node:crypto";
+
 import * as Ink from "ink-cjs";
 import { createStore, useStore } from "zustand";
 import { immer } from "zustand/middleware/immer";
 
+import { DebugOutput } from "~/app/DebugOutput";
 import { Exit } from "~/app/Exit";
-import { LogTimestamp } from "~/app/LogTimestamp";
 import { colors } from "~/core/colors";
 import { pretty_json } from "~/core/pretty_json";
 
@@ -21,13 +23,10 @@ type CommitMap = Parameters<typeof CommitMetadata.range>[0];
 type MutateOutputArgs = {
   node: React.ReactNode;
   id?: string;
-  debug?: boolean;
-  withoutTimestamp?: boolean;
 };
 
 type SyncGithubState = {
   commit_range: CommitMetadata.CommitRange;
-  rebase_group_index: number;
 };
 
 // async function that returns exit code
@@ -73,12 +72,12 @@ export type State = {
     | "sync-github"
     | "post-rebase-status";
 
-  output: Array<React.ReactNode>;
-  pending_output: Record<string, Array<React.ReactNode>>;
+  output: Array<[string, React.ReactNode]>;
+  pending_output: Record<string, Array<string>>;
 
   // cache
   pr: { [branch: string]: PullRequest };
-  cache_pr_diff: { [id: number]: string };
+  cache_gh_cli_by_branch: { [branch: string]: { [command: string]: string } };
 
   actions: {
     exit(code: number, args?: ExitArgs): void;
@@ -88,7 +87,9 @@ export type State = {
     json(value: pretty_json.JSONValue): void;
     error(error: unknown): void;
     output(node: React.ReactNode): void;
-    debug(node: React.ReactNode, id?: string): void;
+    debug(node: React.ReactNode): void;
+    debug_pending(id: string, content: string): void;
+    debug_pending_end(id: string): void;
 
     isDebug(): boolean;
 
@@ -100,8 +101,6 @@ export type State = {
 
   mutate: {
     output(state: State, args: MutateOutputArgs): void;
-    pending_output(state: State, args: MutateOutputArgs): void;
-    end_pending_output(state: State, id: string): void;
   };
 
   select: {
@@ -139,7 +138,7 @@ const BaseStore = createStore<State>()(
     pending_output: {},
 
     pr: {},
-    cache_pr_diff: {},
+    cache_gh_cli_by_branch: {},
 
     actions: {
       exit(code, args) {
@@ -179,7 +178,7 @@ const BaseStore = createStore<State>()(
       json(value) {
         set((state) => {
           const node = pretty_json(value);
-          state.mutate.output(state, { node });
+          state.actions.debug(node);
         });
       },
 
@@ -211,20 +210,32 @@ const BaseStore = createStore<State>()(
         });
       },
 
-      debug(node, id) {
+      debug(node) {
         if (get().actions.isDebug()) {
-          const debug = true;
+          set((state) => {
+            state.mutate.output(state, { node: <DebugOutput node={node} /> });
+          });
+        }
+      },
 
+      debug_pending(id, content) {
+        if (get().actions.isDebug()) {
           set((state) => {
-            if (id) {
-              state.mutate.pending_output(state, { id, node, debug });
-            } else {
-              state.mutate.output(state, { node, debug });
+            if (!state.pending_output[id]) {
+              state.pending_output[id] = [];
             }
+
+            state.pending_output[id].push(content);
           });
         }
       },
 
+      debug_pending_end(id) {
+        set((state) => {
+          delete state.pending_output[id];
+        });
+      },
+
       isDebug() {
         const state = get();
         return state.select.debug(state);
@@ -251,38 +262,8 @@ const BaseStore = createStore<State>()(
 
     mutate: {
       output(state, args) {
-        const renderOutput = renderOutputArgs(args);
-        state.output.push(renderOutput);
-      },
-
-      pending_output(state, args) {
-        const { id } = args;
-
-        if (!id) {
-          return;
-        }
-
-        // set `withoutTimestamp` to skip <LogTimestamp> for all subsequent pending outputs
-        // we only want to timestamp for the first part (when we initialize the [])
-        // if we have many incremental outputs on the same line we do not want multiple timestamps
-        //
-        // await Promise.all([
-        //   cli(`for i in $(seq 1 5); do echo $i; sleep 1; done`),
-        //   cli(`for i in $(seq 5 1); do printf "$i "; sleep 1; done; echo`),
-        // ]);
-        //
-        let withoutTimestamp = true;
-        if (!state.pending_output[id]) {
-          withoutTimestamp = false;
-          state.pending_output[id] = [];
-        }
-
-        const renderOutput = renderOutputArgs({ ...args, withoutTimestamp });
-        state.pending_output[id].push(renderOutput);
-      },
-
-      end_pending_output(state, id) {
-        delete state.pending_output[id];
+        const id = crypto.randomUUID();
+        state.output.push([id, args.node]);
       },
     },
 
@@ -294,28 +275,6 @@ const BaseStore = createStore<State>()(
   })),
 );
 
-function renderOutputArgs(args: MutateOutputArgs) {
-  let output = args.node;
-
-  switch (typeof args.node) {
-    case "boolean":
-    case "number":
-    case "string":
-      output = <Ink.Text dimColor={args.debug}>{String(args.node)}</Ink.Text>;
-  }
-
-  if (args.debug) {
-    return (
-      <React.Fragment>
-        {args.withoutTimestamp ? null : <LogTimestamp />}
-        {output}
-      </React.Fragment>
-    );
-  }
-
-  return output;
-}
-
 function useState<R>(selector: (state: State) => R): R {
   return useStore(BaseStore, selector);
 }

package/src/app/SyncGithub.tsx

@@ -13,6 +13,7 @@ import { colors } from "~/core/colors";
 import * as github from "~/core/github";
 import { invariant } from "~/core/invariant";
 import { safe_exists } from "~/core/safe_exists";
+import { sleep } from "~/core/sleep";
 
 import type * as CommitMetadata from "~/core/CommitMetadata";
 
@@ -25,18 +26,18 @@ async function run() {
   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 master_branch = state.master_branch;
-  const repo_root = state.repo_root;
+  const repo_path = state.repo_path;
   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(repo_path, "repo_path 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;
 
   let DEFAULT_PR_BODY = "";
   if (state.pr_template_body) {
@@ -45,9 +46,6 @@ async function run() {
 
   const push_group_list = get_push_group_list();
 
-  // console.debug({ push_group_list });
-  // throw new Error("STOP");
-
   // for all push targets in push_group_list
   // things that can be done in parallel are grouped by numbers
   //
@@ -159,16 +157,26 @@ async function run() {
 
     actions.unregister_abort_handler();
 
+    // invalidate cache for PRs we pushed
     actions.set((state) => {
-      // invalidate cache for PRs we pushed
       for (const group of push_group_list) {
         if (group.pr) {
           delete state.pr[group.pr.headRefName];
-          delete state.cache_pr_diff[group.pr.number];
+          delete state.cache_gh_cli_by_branch[group.pr.headRefName];
         }
       }
+    });
+
+    // wait a bit for github to settle after push / edits above
+    // we github.pr_list returns outdated information if called too quickly
+    await sleep(400);
 
-      // move to next step
+    // gather all open prs in repo at once
+    // cheaper query to populate cache
+    await github.pr_list();
+
+    // move to next step
+    actions.set((state) => {
       state.step = "post-rebase-status";
     });
   } catch (err) {
@@ -181,24 +189,14 @@ async function run() {
   }
 
   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];
-
+    for (let group of commit_range.group_list) {
       // skip the unassigned commits group
       if (group.id === commit_range.UNASSIGNED) continue;
 
-      // if not --force, skip non-dirty master_base groups
-      if (group.master_base && !group.dirty && !argv.force) continue;
+      // if not --force, skip non-dirty groups
+      if (!group.dirty && !argv.force) continue;
 
       push_group_list.unshift(group);
     }
@@ -229,7 +227,7 @@ async function run() {
       // Unable to sync.
       // ```
       //
-      if (!is_master_base(group)) {
+      if (!is_pr_master_base(group)) {
         await github.pr_edit({
           branch: group.id,
           base: master_branch,
@@ -247,7 +245,15 @@ async function run() {
     invariant(group.base, "group.base must exist");
 
     if (group.pr) {
-      if (!is_master_base(group)) {
+      // there are two scenarios where we should restore the base after push
+      // 1. if we aren't master base and pr is master base we should fix it
+      const base_mismatch = !group.master_base && is_pr_master_base(group);
+      // 2. if group pr was not master before the push we set it to master before pushing
+      //    now we need to restore it back to how it was before the before_push
+      const was_modified_before_push = !is_pr_master_base(group);
+
+      const needs_base_fix = base_mismatch || was_modified_before_push;
+      if (needs_base_fix) {
         // ensure base matches pr in github
         await github.pr_edit({ branch: group.id, base: group.base });
       }
@@ -302,25 +308,31 @@ async function run() {
     }
   }
 
-  function is_master_base(group: CommitMetadataGroup) {
+  function is_pr_master_base(group: CommitMetadataGroup) {
     if (!group.pr) {
       return false;
     }
 
-    return group.master_base || `origin/${group.pr.baseRefName}` === master_branch;
+    return `origin/${group.pr.baseRefName}` === master_branch;
   }
 
   async function push_master_group(group: CommitMetadataGroup) {
-    invariant(repo_root, "repo_root must exist");
+    invariant(repo_path, "repo_path must exist");
 
-    const repo_rel_worktree_path = `.git/git-stack-worktrees/push_master_group`;
-    const worktree_path = path.join(repo_root, repo_rel_worktree_path);
+    const worktree_path = path.join(
+      process.env.HOME,
+      ".cache",
+      "git-stack",
+      "worktrees",
+      repo_path,
+      "push_master_group",
+    );
 
     // ensure worktree for pushing master groups
     if (!(await safe_exists(worktree_path))) {
       actions.output(
         <Ink.Text color={colors.white}>
-          Creating <Ink.Text color={colors.yellow}>{repo_rel_worktree_path}</Ink.Text>
+          Creating <Ink.Text color={colors.yellow}>{worktree_path}</Ink.Text>
         </Ink.Text>,
       );
       actions.output(
@@ -331,13 +343,13 @@ async function run() {
 
     // ensure worktree is clean + on the right base before applying commits
     // - abort any in-progress cherry-pick/rebase
-    // - drop local changes/untracked files (including ignored) for a truly fresh state
+    // - drop local changes/untracked files to fresh state
     // - reset to the desired base
     await cli(`git -C ${worktree_path} cherry-pick --abort`, { ignoreExitCode: true });
     await cli(`git -C ${worktree_path} rebase --abort`, { ignoreExitCode: true });
     await cli(`git -C ${worktree_path} merge --abort`, { ignoreExitCode: true });
     await cli(`git -C ${worktree_path} checkout -f ${master_branch}`);
-    await cli(`git -C ${worktree_path} reset --hard ${master_branch}`);
+    await cli(`git -C ${worktree_path} reset --hard ${merge_base}`);
     await cli(`git -C ${worktree_path} clean -fd`);
 
     // cherry-pick the group commits onto that base

package/src/app/VerboseDebugInfo.tsx

@@ -1,11 +1,14 @@
 import * as React from "react";
 
+import path from "node:path";
+
 import * as Ink from "ink-cjs";
 
 import { Await } from "~/app/Await";
 import { Store } from "~/app/Store";
 import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
+import { pretty_json } from "~/core/pretty_json";
 
 type Props = {
   children: React.ReactNode;
@@ -29,6 +32,11 @@ async function run() {
     await cli(`echo USER=$USER`);
     await cli(`echo GIT_AUTHOR_NAME=$GIT_AUTHOR_NAME`);
     await cli(`echo GIT_AUTHOR_EMAIL=$GIT_AUTHOR_EMAIL`);
+
+    const PATH = process.env["PATH"];
+    const PATH_LIST = pretty_json(PATH.split(path.delimiter));
+    actions.debug(`process.env.PATH ${PATH_LIST}`);
+
     await cli(`git config --list --show-origin`);
   } catch (err) {
     actions.error("Unable to log verbose debug information.");