git-stack-cli 2.9.3 → 2.9.5

package/src/core/github.tsx

@@ -10,6 +10,7 @@ import { Brackets } from "~/app/Brackets";
 import { FormatText } from "~/app/FormatText";
 import { Store } from "~/app/Store";
 import { Timer } from "~/core/Timer";
+import { cache_message } from "~/core/cache_message";
 import { cli } from "~/core/cli";
 import { colors } from "~/core/colors";
 import { get_tmp_dir } from "~/core/get_tmp_dir";
@@ -40,7 +41,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 +101,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 +242,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 +280,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 {
@@ -349,36 +409,6 @@ function safe_filename(value: string): string {
   return value.replace(RE.non_alphanumeric_dash, "-");
 }
 
-type CacheMessageArgs = {
-  hit: boolean;
-  message: React.ReactNode;
-  extra: React.ReactNode;
-};
-
-function cache_message(args: CacheMessageArgs) {
-  const status = args.hit ? (
-    <Ink.Text bold color={colors.green}>
-      HIT
-    </Ink.Text>
-  ) : (
-    <Ink.Text bold color={colors.red}>
-      MISS
-    </Ink.Text>
-  );
-
-  return (
-    <FormatText
-      wrapper={<Ink.Text dimColor />}
-      message="{message} {status} {extra}"
-      values={{
-        message: args.message,
-        status,
-        extra: args.extra,
-      }}
-    />
-  );
-}
-
 type Commit = {
   authoredDate: string; // "2023-10-22T23:13:35Z"
   authors: [
@@ -408,6 +438,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>;
-}

package/src/core/git.ts

@@ -1,83 +0,0 @@
-import { Store } from "~/app/Store";
-import * as Metadata from "~/core/Metadata";
-import { cli } from "~/core/cli";
-import { invariant } from "~/core/invariant";
-
-type CommitList = Awaited<ReturnType<typeof get_commits>>;
-
-export type Commit = CommitList[0];
-
-export async function get_commits(dot_range: string) {
-  const log_result = await cli(`git log ${dot_range} --format=${FORMAT} --color=never`);
-
-  if (!log_result.stdout) {
-    return [];
-  }
-
-  const commit_list = [];
-
-  for (let record of log_result.stdout.split(SEP.record)) {
-    record = record.replace(/^\n/, "");
-    record = record.replace(/\n$/, "");
-
-    if (!record) continue;
-
-    const [sha, full_message] = record.split(SEP.field);
-
-    // ensure sha is a hex string, otherwise we should throw an error
-    if (!RE.git_sha.test(sha)) {
-      const actions = Store.getState().actions;
-      const sep_values = JSON.stringify(Object.values(SEP));
-      const message = `unable to parse git commits, maybe commit message contained ${sep_values}`;
-      actions.error(message);
-      actions.exit(19);
-    }
-
-    const metadata = Metadata.read(full_message);
-    const branch_id = metadata.id;
-    const subject_line = metadata.subject || "";
-    const title = metadata.title;
-    const master_base = metadata.base === "master";
-
-    const commit = {
-      sha,
-      full_message,
-      subject_line,
-      branch_id,
-      title,
-      master_base,
-    };
-
-    commit_list.push(commit);
-  }
-
-  commit_list.reverse();
-
-  return commit_list;
-}
-
-export async function get_diff(commit_list: CommitList) {
-  invariant(commit_list.length, "commit_list must exist");
-  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}`);
-  return diff_result.stdout;
-}
-
-// Why these separators?
-// - Rare in human written text
-// - Supported in git %xNN to write bytes
-// - Supported in javascript \xNN to write bytes
-// - Used historically as separators in unicode
-//   https://en.wikipedia.org/wiki/C0_and_C1_control_codes#Field_separators
-const SEP = {
-  record: "\x1e",
-  field: "\x1f",
-};
-
-const FORMAT = `%H${SEP.field}%B${SEP.record}`;
-
-const RE = {
-  git_sha: /^[0-9a-fA-F]{40}$/,
-};