git-stack-cli 2.9.3 → 2.9.5

package/package.json

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

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/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,13 @@ 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 } };
+  cache_diff: { [key: string]: string };
 
   actions: {
     exit(code: number, args?: ExitArgs): void;
@@ -88,7 +88,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 +102,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 +139,8 @@ const BaseStore = createStore<State>()(
     pending_output: {},
 
     pr: {},
-    cache_pr_diff: {},
+    cache_gh_cli_by_branch: {},
+    cache_diff: {},
 
     actions: {
       exit(code, args) {
@@ -207,24 +208,39 @@ const BaseStore = createStore<State>()(
 
       output(node) {
         set((state) => {
+          if (typeof node === "string") {
+            node = <Ink.Text>{node}</Ink.Text>;
+          }
           state.mutate.output(state, { node });
         });
       },
 
-      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 +267,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 +280,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

@@ -1,7 +1,5 @@
 import * as React from "react";
 
-import path from "node:path";
-
 import * as Ink from "ink-cjs";
 import last from "lodash/last";
 
@@ -10,9 +8,9 @@ import { Store } from "~/app/Store";
 import * as StackSummaryTable from "~/core/StackSummaryTable";
 import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
+import * as git from "~/core/git";
 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";
@@ -28,16 +26,15 @@ async function run() {
   const branch_name = state.branch_name;
   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) {
@@ -46,9 +43,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
   //
@@ -165,7 +159,7 @@ async function run() {
       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];
         }
       }
     });
@@ -192,24 +186,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);
     }
@@ -240,7 +224,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,
@@ -258,7 +242,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 });
       }
@@ -313,47 +305,19 @@ 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");
-
-    const repo_rel_worktree_path = `.git/git-stack-worktrees/push_master_group`;
-    const worktree_path = path.join(repo_root, repo_rel_worktree_path);
-
-    // 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>
-        </Ink.Text>,
-      );
-      actions.output(
-        <Ink.Text color={colors.gray}>(this may take a moment the first time…)</Ink.Text>,
-      );
-      await cli(`git worktree add -f ${worktree_path} ${master_branch}`);
-    }
+    invariant(repo_path, "repo_path must exist");
 
-    // 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
-    // - 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} clean -fd`);
-
-    // cherry-pick the group commits onto that base
-    const cp_commit_list = group.commits.map((c) => c.sha).join(" ");
-    await cli(`git -C ${worktree_path} cherry-pick ${cp_commit_list}`);
+    const commit_list = group.commits;
+    const { worktree_path } = await git.worktree_add({ commit_list });
 
     const push_target = `HEAD:refs/heads/${group.id}`;
     const git_push_command = create_git_push_command(`git -C ${worktree_path}`, push_target);

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.");