git-stack-cli 2.9.2 → 2.9.4

package/src/core/CommitMetadata.ts

@@ -3,6 +3,7 @@
 import { Store } from "~/app/Store";
 import * as git from "~/core/git";
 import * as github from "~/core/github";
+import { invariant } from "~/core/invariant";
 
 export type CommitRange = Awaited<ReturnType<typeof range>>;
 
@@ -28,16 +29,16 @@ type CommitRangeGroup = {
 type CommitGroupMap = { [sha: string]: CommitRangeGroup };
 
 export async function range(commit_group_map?: CommitGroupMap) {
-  const DEBUG = process.env.DEV && false;
-
-  // gather all open prs in repo first
-  // cheaper query to populate cache
-  await github.pr_list();
-
-  const master_branch = Store.getState().master_branch;
+  const state = Store.getState();
+  const actions = state.actions;
+  const argv = state.argv;
+  const merge_base = state.merge_base;
+  const master_branch = state.master_branch;
   const master_branch_name = master_branch.replace(/^origin\//, "");
   const commit_list = await git.get_commits(`${master_branch}..HEAD`);
 
+  invariant(merge_base, "merge_base must exist");
+
   const pr_lookup: Record<string, void | PullRequest> = {};
 
   let invalid = false;
@@ -127,6 +128,15 @@ export async function range(commit_group_map?: CommitGroupMap) {
     const group = group_value_list[i];
     const previous_group: undefined | CommitGroup = group_value_list[i - 1];
 
+    // actions.json({ group });
+    actions.debug(`title=${group.title}`);
+    actions.debug(`  id=${group.id}`);
+    actions.debug(`  master_base=${group.master_base}`);
+
+    // special case
+    // boundary between normal commits and master commits
+    const MASTER_BASE_BOUNDARY = !group.master_base && previous_group && previous_group.master_base;
+
     if (group.id !== UNASSIGNED) {
       let pr_result = pr_lookup[group.id];
 
@@ -147,9 +157,8 @@ export async function range(commit_group_map?: CommitGroupMap) {
     if (i === 0) {
       group.base = master_branch_name;
     } else {
-      const last_group = group_value_list[i - 1];
-      // console.debug("  ", "last_group", last_group.pr?.title.substring(0, 40));
-      // console.debug("  ", "last_group.id", last_group.id);
+      // console.debug("  ", "previous_group", previous_group.pr?.title.substring(0, 40));
+      // console.debug("  ", "previous_group.id", previous_group.id);
 
       if (group.master_base) {
         // explicitly set base to master when master_base is true
@@ -157,77 +166,93 @@ export async function range(commit_group_map?: CommitGroupMap) {
       } else if (group.id === UNASSIGNED) {
         // null out base when unassigned and after unassigned
         group.base = null;
-      } else if (last_group.base === null) {
+      } else if (MASTER_BASE_BOUNDARY) {
+        // ensure we set its base to `master`
+        actions.debug(`  MASTER_BASE_BOUNDARY set group.base = ${master_branch_name}`);
+        group.base = master_branch_name;
+      } else if (previous_group.base === null) {
         // null out base when last group base is null
         group.base = null;
       } else {
-        group.base = last_group.id;
+        group.base = previous_group.id;
       }
-
-      // console.debug("  ", "group.base", group.base);
     }
 
-    if (DEBUG) {
-      console.debug({ group });
-    }
+    actions.debug(`  base=${group.base}`);
 
     if (!group.pr) {
+      actions.debug(`  group.pr=${group.pr}`);
       group.dirty = true;
     } else {
-      if (group.pr.baseRefName !== group.base) {
-        // console.debug("PR_BASEREF_MISMATCH");
+      // actions.json(group.pr);
+      actions.debug(`  group.pr.state=${group.pr.state}`);
+      actions.debug(`  group.pr.baseRefName=${group.pr.baseRefName}`);
+
+      if (group.pr.state === "MERGED" || group.pr.state === "CLOSED") {
+        group.dirty = true;
+      } else if (group.pr.baseRefName !== group.base) {
+        actions.debug("  PR_BASEREF_MISMATCH");
         group.dirty = true;
       } else if (group.master_base) {
-        // console.debug("MASTER_BASE_DIFF_COMPARE");
-
-        // special case
-        // master_base groups cannot be compared by commit sha
-        // instead compare the literal diff local against origin
-        // gh pr diff --color=never 110
-        // git --no-pager diff --color=never 00c8fe0~1..00c8fe0
-        let diff_github = await github.pr_diff(group.pr.number);
-        diff_github = normalize_diff(diff_github);
-
-        let diff_local = await git.get_diff(group.commits);
-        diff_local = normalize_diff(diff_local);
-
-        if (DEBUG) {
-          console.debug({ diff_local, diff_github });
+        // first check if merge base has changed
+        let branch_compare = await github.pr_compare(group.pr.headRefName);
+        if (!(branch_compare instanceof Error)) {
+          if (branch_compare.merge_base_commit.sha !== merge_base) {
+            actions.debug("  MASTER_BASE_MERGE_BASE_MISMATCH");
+            group.dirty = true;
+          }
         }
 
-        // find the first differing character index
-        let compare_length = Math.max(diff_github.length, diff_local.length);
-        let diff_index = -1;
-        for (let c_i = 0; c_i < compare_length; c_i++) {
-          if (diff_github[c_i] !== diff_local[c_i]) {
-            diff_index = c_i;
-            break;
+        // if still not dirty, check diffs
+        if (!group.dirty) {
+          actions.debug("  MASTER_BASE_DIFF_COMPARE");
+
+          // special case
+          // master_base groups cannot be compared by commit sha
+          // instead compare the literal diff local against origin
+          // gh pr diff --color=never 110
+          // git --no-pager diff --color=never 00c8fe0~1..00c8fe0
+          let diff_github = await github.pr_diff(group.pr.headRefName);
+          diff_github = normalize_diff(diff_github);
+
+          let diff_local = await git.get_diff(group.commits);
+          diff_local = normalize_diff(diff_local);
+
+          // find the first differing character index
+          let compare_length = Math.max(diff_github.length, diff_local.length);
+          let diff_index = -1;
+          for (let c_i = 0; c_i < compare_length; c_i++) {
+            if (diff_github[c_i] !== diff_local[c_i]) {
+              diff_index = c_i;
+              break;
+            }
           }
-        }
-        if (diff_index > -1) {
-          group.dirty = true;
+          if (diff_index > -1) {
+            actions.debug("  MASTER_BASE_DIFF_MISMATCH");
+            group.dirty = true;
 
-          if (DEBUG) {
-            // print preview at diff_index for both strings
-            const preview_radius = 30;
-            const start_index = Math.max(0, diff_index - preview_radius);
-            const end_index = Math.min(compare_length, diff_index + preview_radius);
+            if (argv.verbose) {
+              // print preview at diff_index for both strings
+              const preview_radius = 30;
+              const start_index = Math.max(0, diff_index - preview_radius);
+              const end_index = Math.min(compare_length, diff_index + preview_radius);
 
-            diff_github = diff_github.substring(start_index, end_index);
-            diff_github = JSON.stringify(diff_github).slice(1, -1);
+              diff_github = diff_github.substring(start_index, end_index);
+              diff_github = JSON.stringify(diff_github).slice(1, -1);
 
-            diff_local = diff_local.substring(start_index, end_index);
-            diff_local = JSON.stringify(diff_local).slice(1, -1);
+              diff_local = diff_local.substring(start_index, end_index);
+              diff_local = JSON.stringify(diff_local).slice(1, -1);
 
-            let pointer_indent = " ".repeat(diff_index - start_index + 1);
-            console.warn(`⚠️ git diff mismatch`);
-            console.warn(`              ${pointer_indent}⌄`);
-            console.warn(`diff_github  …${diff_github}…`);
-            console.warn(`diff_local   …${diff_local}…`);
-            console.warn(`              ${pointer_indent}⌃`);
+              let pointer_indent = " ".repeat(diff_index - start_index + 1);
+              actions.debug(`  ⚠️ git diff mismatch`);
+              actions.debug(`                ${pointer_indent}⌄`);
+              actions.debug(`  diff_github  …${diff_github}…`);
+              actions.debug(`  diff_local   …${diff_local}…`);
+              actions.debug(`                ${pointer_indent}⌃`);
+            }
           }
         }
-      } else if (!group.master_base && previous_group && previous_group.master_base) {
+      } else if (MASTER_BASE_BOUNDARY) {
         // special case
         // boundary between normal commits and master commits
 
@@ -245,24 +270,23 @@ export async function range(commit_group_map?: CommitGroupMap) {
 
         // compare all commits against pr commits
         if (group.pr.commits.length !== all_commits.length) {
-          // console.debug("BOUNDARY_COMMIT_LENGTH_MISMATCH");
+          actions.debug("  BOUNDARY_COMMIT_LENGTH_MISMATCH");
           group.dirty = true;
         } else {
-          // console.debug("BOUNDARY_COMMIT_SHA_COMPARISON");
           for (let i = 0; i < group.pr.commits.length; i++) {
             const pr_commit = group.pr.commits[i];
             const local_commit = all_commits[i];
 
             if (pr_commit.oid !== local_commit.sha) {
+              actions.debug("  BOUNDARY_COMMIT_SHA_MISMATCH");
               group.dirty = true;
             }
           }
         }
       } else if (group.pr.commits.length !== group.commits.length) {
-        // console.debug("COMMIT_LENGTH_MISMATCH");
+        actions.debug("  COMMIT_LENGTH_MISMATCH");
         group.dirty = true;
       } else {
-        // console.debug("COMMIT_SHA_COMPARISON");
         // if we still haven't marked this dirty, check each commit
         // comapre literal commit shas in group
         for (let i = 0; i < group.pr.commits.length; i++) {
@@ -270,13 +294,14 @@ export async function range(commit_group_map?: CommitGroupMap) {
           const local_commit = group.commits[i];
 
           if (pr_commit.oid !== local_commit.sha) {
+            actions.debug("  COMMIT_SHA_MISMATCH");
             group.dirty = true;
           }
         }
       }
     }
 
-    // console.debug("  ", "group.dirty", group.dirty);
+    actions.debug(`  group.dirty=${group.dirty}`);
   }
 
   // reverse group_list to match git log

package/src/core/cli.ts

@@ -8,6 +8,7 @@ type SpawnOptions = Parameters<typeof child.spawn>[2];
 type Options = SpawnOptions & {
   ignoreExitCode?: boolean;
   onOutput?: (data: string) => void;
+  quiet?: boolean;
 };
 
 type Return = {
@@ -45,13 +46,15 @@ export async function cli(
 
     const id = `${++i}-${command}`;
     state.actions.debug(log.start(command));
-    state.actions.debug(log.pending(command), id);
+    state.actions.debug_pending(id, log.pending(command));
 
     const timer = Timer();
 
     function write_output(value: string) {
       output += value;
-      state.actions.debug(value, id);
+      if (!options.quiet) {
+        state.actions.debug_pending(id, value);
+      }
       options.onOutput?.(value);
     }
 
@@ -79,9 +82,11 @@ export async function cli(
         duration,
       };
 
-      state.actions.set((state) => state.mutate.end_pending_output(state, id));
+      state.actions.debug_pending_end(id);
       state.actions.debug(log.end(result));
-      state.actions.debug(log.output(result));
+      if (!options.quiet) {
+        state.actions.debug(log.output(result));
+      }
 
       if (!options.ignoreExitCode && result.code !== 0) {
         state.actions.debug(log.non_zero_exit(result));
@@ -133,7 +138,9 @@ cli.sync = function cli_sync(
   };
 
   state.actions.debug(log.end(result));
-  state.actions.debug(log.output(result));
+  if (!options.quiet) {
+    state.actions.debug(log.output(result));
+  }
 
   if (!options.ignoreExitCode && result.code !== 0) {
     state.actions.debug(log.non_zero_exit(result));

package/src/core/git.ts

@@ -61,7 +61,7 @@ export async function get_diff(commit_list: CommitList) {
   const first_commit = commit_list[0];
   const last_commit = commit_list[commit_list.length - 1];
   const sha_range = `${first_commit.sha}~1..${last_commit.sha}`;
-  const diff_result = await cli(`git --no-pager diff --color=never ${sha_range}`);
+  const diff_result = await cli(`git --no-pager diff --color=never ${sha_range}`, { quiet: true });
   return diff_result.stdout;
 }
 

package/src/core/github.tsx

@@ -40,7 +40,6 @@ export async function pr_list(): Promise<Array<PullRequest>> {
   if (actions.isDebug()) {
     actions.output(
       <FormatText
-        wrapper={<Ink.Text dimColor />}
         message="Github cache {count} open PRs from {repo_path} authored by {username}"
         values={{
           count: (
@@ -101,7 +100,8 @@ export async function pr_status(branch: string): Promise<null | PullRequest> {
     );
   }
 
-  const pr = await gh_json<PullRequest>(`pr view ${branch} --repo ${repo_path} ${JSON_FIELDS}`);
+  const commmand = `pr view ${branch} --repo ${repo_path} ${JSON_FIELDS}`;
+  const pr = await gh_json<PullRequest>(commmand, { branch });
 
   if (pr instanceof Error) {
     return null;
@@ -241,48 +241,37 @@ export async function pr_draft(args: DraftPullRequestArgs) {
   }
 }
 
-export async function pr_diff(number: number) {
-  const state = Store.getState();
-  const actions = state.actions;
+export async function pr_diff(branch: string) {
+  // https://cli.github.com/manual/gh_pr_diff
+  const result = await gh(`pr diff --color=never ${branch}`, { branch });
 
-  const maybe_diff = state.cache_pr_diff[number];
+  if (result instanceof Error) {
+    handle_error(result.message);
+  }
 
-  if (maybe_diff) {
-    if (actions.isDebug()) {
-      actions.debug(
-        cache_message({
-          hit: true,
-          message: "Github pr_diff cache",
-          extra: number,
-        }),
-      );
-    }
+  return result;
+}
 
-    return maybe_diff;
-  }
+export async function pr_compare(branch: string) {
+  const state = Store.getState();
+  const master_branch = state.master_branch;
+  const repo_path = state.repo_path;
+  invariant(master_branch, "master_branch must exist");
+  invariant(repo_path, "repo_path must exist");
 
-  if (actions.isDebug()) {
-    actions.debug(
-      cache_message({
-        hit: false,
-        message: "Github pr_diff cache",
-        extra: number,
-      }),
-    );
-  }
+  const master_branch_name = master_branch.replace(/^origin\//, "");
 
-  // https://cli.github.com/manual/gh_pr_diff
-  const cli_result = await cli(`gh pr diff --color=never ${number}`);
+  // gh api repos/openai/openai/compare/master...chrome/publish/vine-1211---4h2xmw0o3ndvnt
+  const result = await gh_json<BranchCompare>(
+    `api repos/${repo_path}/compare/${master_branch_name}...${branch}`,
+    { branch },
+  );
 
-  if (cli_result.code !== 0) {
-    handle_error(cli_result.output);
+  if (result instanceof Error) {
+    handle_error(result.message);
   }
 
-  actions.set((state) => {
-    state.cache_pr_diff[number] = cli_result.output;
-  });
-
-  return cli_result.stdout;
+  return result;
 }
 
 // pull request JSON fields
@@ -290,29 +279,99 @@ export async function pr_diff(number: number) {
 // prettier-ignore
 const JSON_FIELDS = "--json id,number,state,baseRefName,headRefName,commits,title,body,url,isDraft";
 
+type GhCmdOptions = {
+  branch?: string;
+};
+
 // consistent handle gh cli commands returning json
 // redirect to tmp file to avoid scrollback overflow causing scrollback to be cleared
-async function gh_json<T>(command: string): Promise<T | Error> {
+async function gh_json<T>(command: string, gh_options?: GhCmdOptions): Promise<T | Error> {
+  const gh_result = await gh(command, gh_options);
+
+  if (gh_result instanceof Error) {
+    return gh_result;
+  }
+
+  try {
+    const json = JSON.parse(gh_result);
+    return json as T;
+  } catch (error) {
+    return new Error(`gh_json JSON.parse: ${error}`);
+  }
+}
+
+// consistent handle gh cli commands
+// redirect to tmp file to avoid scrollback overflow causing scrollback to be cleared
+async function gh(command: string, gh_options?: GhCmdOptions): Promise<string | Error> {
+  const state = Store.getState();
+  const actions = state.actions;
+
+  if (gh_options?.branch) {
+    const branch = gh_options.branch;
+
+    type CacheEntryByHeadRefName = (typeof state.cache_gh_cli_by_branch)[string][string];
+
+    let cache: undefined | CacheEntryByHeadRefName = undefined;
+
+    if (branch) {
+      if (state.cache_gh_cli_by_branch[branch]) {
+        cache = state.cache_gh_cli_by_branch[branch][command];
+      }
+    }
+
+    if (cache) {
+      if (actions.isDebug()) {
+        actions.debug(
+          cache_message({
+            hit: true,
+            message: "gh cache",
+            extra: command,
+          }),
+        );
+      }
+
+      return cache;
+    }
+
+    if (actions.isDebug()) {
+      actions.debug(
+        cache_message({
+          hit: false,
+          message: "gh cache",
+          extra: command,
+        }),
+      );
+    }
+  }
+
   // hash command for unique short string
   let hash = crypto.createHash("md5").update(command).digest("hex");
-  let tmp_filename = safe_filename(`gh_json-${hash}`);
-  const tmp_pr_json = path.join(await get_tmp_dir(), `${tmp_filename}.json`);
+  let tmp_filename = safe_filename(`gh-${hash}`);
+  const tmp_filepath = path.join(await get_tmp_dir(), `${tmp_filename}`);
 
   const options = { ignoreExitCode: true };
-  const cli_result = await cli(`gh ${command} > ${tmp_pr_json}`, options);
+  const cli_result = await cli(`gh ${command} > ${tmp_filepath}`, options);
 
   if (cli_result.code !== 0) {
     return new Error(cli_result.output);
   }
 
   // read from file
-  const json_str = String(await fs.readFile(tmp_pr_json));
-  try {
-    const json = JSON.parse(json_str);
-    return json;
-  } catch (error) {
-    return new Error(`gh_json JSON.parse: ${error}`);
+  let content = String(await fs.readFile(tmp_filepath));
+  content = content.trim();
+
+  if (gh_options?.branch) {
+    const branch = gh_options.branch;
+
+    actions.set((state) => {
+      if (!state.cache_gh_cli_by_branch[branch]) {
+        state.cache_gh_cli_by_branch[branch] = {};
+      }
+      state.cache_gh_cli_by_branch[branch][command] = content;
+    });
   }
+
+  return content;
 }
 
 function handle_error(output: string): never {
@@ -408,6 +467,36 @@ export type PullRequest = {
   isDraft: boolean;
 };
 
+type MergeBaseCommit = {
+  author: unknown;
+  comments_url: string;
+  commit: unknown;
+  committer: unknown;
+  html_url: string;
+  node_id: string;
+  parents: unknown;
+  sha: string;
+  url: string;
+};
+
+export type BranchCompare = {
+  ahead_by: number;
+  base_commit: unknown;
+  behind_by: number;
+  commits: unknown;
+  diff_url: string;
+
+  files: unknown;
+  html_url: string;
+
+  merge_base_commit: MergeBaseCommit;
+  patch_url: string;
+  permalink_url: string;
+  status: unknown;
+  total_commits: number;
+  url: string;
+};
+
 const RE = {
   non_alphanumeric_dash: /[^a-zA-Z0-9_-]+/g,
 };

package/src/index.tsx

@@ -5,7 +5,6 @@
 import * as React from "react";
 
 import fs from "node:fs/promises";
-import path from "node:path";
 
 import * as Ink from "ink-cjs";
 
@@ -61,10 +60,6 @@ import { pretty_json } from "~/core/pretty_json";
 
     actions.debug(pretty_json(argv as any));
 
-    const PATH = process.env["PATH"];
-    const PATH_LIST = pretty_json(PATH.split(path.delimiter));
-    actions.debug(`process.env.PATH ${PATH_LIST}`);
-
     await ink.waitUntilExit();
 
     function maybe_verbose_help() {

package/src/types/global.d.ts

@@ -1,6 +1,7 @@
 declare namespace NodeJS {
   interface ProcessEnv {
     PATH: string;
+    HOME: string;
     DEV?: "true" | "false";
     CLI_VERSION?: string;
     GIT_SEQUENCE_EDITOR_SCRIPT?: string;

package/src/app/LogTimestamp.tsx

@@ -1,8 +0,0 @@
-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>;
-}