git-stack-cli 1.0.2 → 1.0.4

package/src/core/chalk.ts

@@ -0,0 +1,103 @@
+import chalk from "chalk";
+
+type ChalkInstance = typeof chalk;
+
+interface ColorProxy extends ChalkInstance {
+  test(): void;
+  bracket(str: string): string;
+  url(str: string): this;
+  cmd(str: string): this;
+  branch(str: string): this;
+}
+
+function create_color_proxy(base: typeof chalk): ColorProxy {
+  return new Proxy(base as ColorProxy, {
+    get(target, prop: keyof ColorProxy) {
+      switch (prop) {
+        case "test":
+          return test;
+
+        case "bracket":
+          return (str: string) =>
+            [
+              target.bold.whiteBright("["),
+              str,
+              target.bold.whiteBright("]"),
+            ].join("");
+
+        case "url":
+          return target.bold.underline.blueBright;
+        case "cmd":
+          return target.bold.yellow;
+        case "branch":
+          return target.bold.green;
+      }
+
+      const target_prop = target[prop];
+
+      return target_prop;
+    },
+    apply(target, _this_arg, arguments_list) {
+      return target(...arguments_list);
+    },
+  });
+}
+export const color = create_color_proxy(chalk);
+
+function test() {
+  const PROP_LIST = [
+    "reset", // Reset the current style.
+    "bold", // Make the text bold.
+    "dim", // Make the text have lower opacity.
+    "italic", // Make the text italic. (Not widely supported)
+    "underline", // Put a horizontal line below the text. (Not widely supported)
+    "overline", // Put a horizontal line above the text. (Not widely supported)
+    "inverse", // Invert background and foreground colors.
+    "hidden", // Print the text but make it invisible.
+    "strikethrough", // Puts a horizontal line through the center of the text. (Not widely supported)
+    "visible", // Print the text only when Chalk has a color level above zero. Can be useful for things that are purely cosmetic.
+
+    "black",
+    "red",
+    "green",
+    "yellow",
+    "blue",
+    "magenta",
+    "cyan",
+    "white",
+    "blackBright",
+    "gray",
+    "grey",
+    "redBright",
+    "greenBright",
+    "yellowBright",
+    "blueBright",
+    "magentaBright",
+    "cyanBright",
+    "whiteBright",
+
+    "bgBlack",
+    "bgRed",
+    "bgGreen",
+    "bgYellow",
+    "bgBlue",
+    "bgMagenta",
+    "bgCyan",
+    "bgWhite",
+    "bgBlackBright",
+    "bgGray",
+    "bgGrey",
+    "bgRedBright",
+    "bgGreenBright",
+    "bgYellowBright",
+    "bgBlueBright",
+    "bgMagentaBright",
+    "bgCyanBright",
+    "bgWhiteBright",
+  ] as const;
+
+  for (const prop of PROP_LIST) {
+    // eslint-disable-next-line no-console
+    console.debug(chalk[prop](prop));
+  }
+}

package/src/core/clamp.ts

@@ -0,0 +1,6 @@
+export function clamp(value: number, min: number, max: number) {
+  let result = value;
+  result = Math.max(result, min);
+  result = Math.min(result, max);
+  return result;
+}

package/src/core/cli.ts

@@ -0,0 +1,161 @@
+import * as child from "node:child_process";
+
+import { Store } from "~/app/Store";
+import { Timer } from "~/core/Timer";
+
+type SpawnOptions = Parameters<typeof child.spawn>[2];
+
+type Options = SpawnOptions & {
+  ignoreExitCode?: boolean;
+};
+
+type Return = {
+  command: string;
+  code: number;
+  stdout: string;
+  stderr: string;
+  output: string;
+  duration: string;
+};
+
+let i = 0;
+
+export async function cli(
+  unsafe_command: string | Array<string | number>,
+  unsafe_options?: Options
+): Promise<Return> {
+  const options = Object.assign({}, unsafe_options);
+
+  const state = Store.getState();
+
+  let command: string;
+  if (Array.isArray(unsafe_command)) {
+    command = unsafe_command.join(" ");
+  } else {
+    command = unsafe_command;
+  }
+
+  return new Promise((resolve, reject) => {
+    const childProcess = child.spawn("sh", ["-c", command], options);
+
+    let stdout = "";
+    let stderr = "";
+    let output = "";
+
+    const id = `${++i}-${command}`;
+    state.actions.debug(log.start(command));
+    state.actions.debug(log.pending(command), id);
+
+    const timer = Timer();
+
+    function write_output(value: string) {
+      output += value;
+      state.actions.debug(value, id);
+    }
+
+    childProcess.stdout?.on("data", (data: Buffer) => {
+      const value = String(data);
+      stdout += value;
+      write_output(value);
+    });
+
+    childProcess.stderr?.on("data", (data: Buffer) => {
+      const value = String(data);
+      stderr += value;
+      write_output(value);
+    });
+
+    childProcess.on("close", (unsafe_code) => {
+      const duration = timer.duration();
+
+      const result = {
+        command,
+        code: unsafe_code || 0,
+        stdout: stdout.trimEnd(),
+        stderr: stderr.trimEnd(),
+        output: output.trimEnd(),
+        duration,
+      };
+
+      state.actions.set((state) => state.mutate.end_pending_output(state, id));
+      state.actions.debug(log.end(result));
+      state.actions.debug(result.output);
+      state.actions.debug("\n");
+
+      if (!options.ignoreExitCode && result.code !== 0) {
+        reject(new Error(log.error(result)));
+      } else {
+        resolve(result);
+      }
+    });
+
+    childProcess.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+cli.sync = function cli_sync(
+  unsafe_command: string | Array<string | number>,
+  unsafe_options?: Options
+): Return {
+  const options = Object.assign({}, unsafe_options);
+
+  const state = Store.getState();
+
+  let command: string;
+  if (Array.isArray(unsafe_command)) {
+    command = unsafe_command.join(" ");
+  } else {
+    command = unsafe_command;
+  }
+
+  state.actions.debug(log.start(command));
+
+  const timer = Timer();
+
+  const spawn_return = child.spawnSync("sh", ["-c", command], options);
+
+  const duration = timer.duration();
+
+  const stdout = String(spawn_return.stdout);
+  const stderr = String(spawn_return.stderr);
+
+  const result = {
+    command,
+    code: spawn_return.status || 0,
+    stdout,
+    stderr,
+    output: [stdout, stderr].join(""),
+    duration,
+  };
+
+  state.actions.debug(log.end(result));
+  state.actions.debug(result.output);
+
+  if (!options.ignoreExitCode && result.code !== 0) {
+    throw new Error(log.error(result));
+  }
+
+  return result;
+};
+
+const log = {
+  start(command: string) {
+    return `[start] ${command}`;
+  },
+
+  pending(command: string) {
+    return `[⏳] ${command}\n`;
+  },
+
+  end(result: Return) {
+    const { command, code, duration } = result;
+    return `[end] ${command} (exit_code=${code} duration=${duration})`;
+  },
+
+  error(result: Return) {
+    const { command, code, duration } = result;
+    return `${command} (exit_code=${code} duration=${duration})`;
+  },
+};

package/src/core/colors.ts

@@ -0,0 +1,23 @@
+// ink uses chalk internally
+// https://github.com/vadimdemedes/ink#color
+
+export const colors = {
+  red: "rgb(248, 81, 73)",
+  // red-emphasis rgb(218, 54, 51)
+
+  green: "rgb(63, 185, 80)",
+  // green-emphasis rgb(35, 134, 54)
+
+  purple: "rgb(163, 113, 247)",
+  // purple-emphasis rgb(137, 87, 229)
+
+  blue: "rgb(47, 129, 247)",
+
+  orange: "rgb(255, 166, 87)",
+
+  yellow: "rgb(234, 179, 8)",
+
+  gray: "rgb(110, 118, 129)",
+
+  lightGray: "rgb(125, 133, 144)",
+};

package/src/core/date.ts

@@ -0,0 +1,25 @@
+export function format(date: Date) {
+  const year = intl_format(date, { year: "numeric" });
+  const month = intl_format(date, { month: "2-digit" });
+  const day = intl_format(date, { day: "2-digit" });
+
+  const time = format_time(date);
+
+  return `${year}-${month}-${day} ${time}`;
+}
+
+type IntlDateTimeFormatOptions = Parameters<typeof Intl.DateTimeFormat>[1];
+
+export function intl_format(date: Date, options: IntlDateTimeFormatOptions) {
+  return new Intl.DateTimeFormat("en-US", options).format(date);
+}
+
+export function format_time(date: Date) {
+  const time = intl_format(date, {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+  });
+
+  return time;
+}

package/src/core/fetch_json.ts

@@ -0,0 +1,26 @@
+import https from "node:https";
+
+export async function fetch_json<T = any>(url: string): Promise<T> {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, (res) => {
+        let data = "";
+
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            resolve(json);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      })
+      .on("error", (error) => {
+        reject(error);
+      });
+  });
+}

package/src/core/github.tsx

@@ -0,0 +1,215 @@
+import * as React from "react";
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import * as Ink from "ink-cjs";
+
+import { Brackets } from "~/app/Brackets";
+import { Store } from "~/app/Store";
+import { cli } from "~/core/cli";
+import { colors } from "~/core/colors";
+import { invariant } from "~/core/invariant";
+import { safe_quote } from "~/core/safe_quote";
+
+// prettier-ignore
+const JSON_FIELDS = "--json number,state,baseRefName,headRefName,commits,title,body,url";
+
+export async function pr_list(): Promise<Array<PullRequest>> {
+  const state = Store.getState();
+  const actions = state.actions;
+
+  const username = state.username;
+  const repo_path = state.repo_path;
+  invariant(username, "username must exist");
+  invariant(repo_path, "repo_path must exist");
+
+  const cli_result = await cli(
+    `gh pr list --repo ${repo_path} --author ${username} --state open ${JSON_FIELDS}`,
+    {
+      ignoreExitCode: true,
+    }
+  );
+
+  if (cli_result.code !== 0) {
+    handle_error(cli_result.output);
+  }
+
+  const result_pr_list: Array<PullRequest> = JSON.parse(cli_result.stdout);
+
+  if (actions.isDebug()) {
+    actions.output(
+      <Ink.Text dimColor>
+        <Ink.Text>{"Github cache "}</Ink.Text>
+        <Ink.Text bold color={colors.yellow}>
+          {result_pr_list.length}
+        </Ink.Text>
+        <Ink.Text>{" open PRs from "}</Ink.Text>
+        <Brackets>{repo_path}</Brackets>
+        <Ink.Text>{" authored by "}</Ink.Text>
+        <Brackets>{username}</Brackets>
+      </Ink.Text>
+    );
+  }
+
+  actions.set((state) => {
+    for (const pr of result_pr_list) {
+      state.pr[pr.headRefName] = pr;
+    }
+  });
+
+  return result_pr_list;
+}
+
+export async function pr_status(branch: string): Promise<null | PullRequest> {
+  const state = Store.getState();
+  const actions = state.actions;
+
+  const username = state.username;
+  const repo_path = state.repo_path;
+  invariant(username, "username must exist");
+  invariant(repo_path, "repo_path must exist");
+
+  const cache = state.pr[branch];
+
+  if (cache) {
+    if (actions.isDebug()) {
+      actions.output(
+        <Ink.Text>
+          <Ink.Text dimColor>Github pr_status cache</Ink.Text>
+          <Ink.Text> </Ink.Text>
+          <Ink.Text bold color={colors.green}>
+            {"HIT "}
+          </Ink.Text>
+          <Ink.Text> </Ink.Text>
+          <Ink.Text dimColor>{branch}</Ink.Text>
+        </Ink.Text>
+      );
+    }
+
+    return cache;
+  }
+
+  if (actions.isDebug()) {
+    actions.output(
+      <Ink.Text>
+        <Ink.Text dimColor>Github pr_status cache</Ink.Text>
+        <Ink.Text> </Ink.Text>
+        <Ink.Text bold color={colors.red}>
+          MISS
+        </Ink.Text>
+        <Ink.Text> </Ink.Text>
+        <Ink.Text dimColor>{branch}</Ink.Text>
+      </Ink.Text>
+    );
+  }
+
+  const cli_result = await cli(
+    `gh pr view ${branch} --repo ${repo_path} ${JSON_FIELDS}`,
+    {
+      ignoreExitCode: true,
+    }
+  );
+
+  if (cli_result.code !== 0) {
+    // handle_error(cli_result.output);
+    return null;
+  }
+
+  const pr: PullRequest = JSON.parse(cli_result.stdout);
+
+  actions.set((state) => {
+    state.pr[pr.headRefName] = pr;
+  });
+
+  return pr;
+}
+
+type CreatePullRequestArgs = {
+  branch: string;
+  base: string;
+  title: string;
+  body: string;
+};
+
+export async function pr_create(args: CreatePullRequestArgs) {
+  const title = safe_quote(args.title);
+
+  const cli_result = await cli(
+    `gh pr create --fill --head ${args.branch} --base ${args.base} --title="${title}" --body="${args.body}"`
+  );
+
+  if (cli_result.code !== 0) {
+    handle_error(cli_result.output);
+    return null;
+  }
+
+  return cli_result.stdout;
+}
+
+type EditPullRequestArgs = {
+  branch: string;
+  base: string;
+  body: string;
+};
+
+export async function pr_edit(args: EditPullRequestArgs) {
+  const cli_result = await cli(
+    // prettier-ignore
+    `gh pr edit ${args.branch} --base ${args.base} --body-file="${body_file(args.body)}"`
+  );
+
+  if (cli_result.code !== 0) {
+    handle_error(cli_result.output);
+  }
+}
+
+function handle_error(output: string): never {
+  const state = Store.getState();
+  const actions = state.actions;
+
+  actions.set((state) => {
+    state.step = "github-api-error";
+  });
+
+  throw new Error(output);
+}
+
+// convert a string to a file for use via github cli `--body-file`
+function body_file(body: string) {
+  const temp_dir = os.tmpdir();
+  const temp_path = path.join(temp_dir, "git-stack-body");
+  if (fs.existsSync(temp_path)) {
+    fs.rmSync(temp_path);
+  }
+  fs.writeFileSync(temp_path, body);
+  return temp_path;
+}
+
+type Commit = {
+  authoredDate: string; // "2023-10-22T23:13:35Z"
+  authors: [
+    {
+      email: string;
+      id: string;
+      login: string; // magus
+      name: string; // magus
+    },
+  ];
+  committedDate: string; // "2023-10-23T08:41:27Z"
+  messageBody: string;
+  messageHeadline: string;
+  oid: string; // "ce7eadaa73518a92ae6a892c1e54c4f4afa6fbdd"
+};
+
+export type PullRequest = {
+  number: number;
+  state: "OPEN" | "MERGED" | "CLOSED";
+  baseRefName: string;
+  headRefName: string;
+  commits: Array<Commit>;
+  title: string;
+  body: string;
+  url: string;
+};

package/src/core/invariant.ts

@@ -0,0 +1,5 @@
+export function invariant(condition: any, message: string): asserts condition {
+  if (!condition) {
+    throw new Error(message);
+  }
+}

package/src/core/is_command_available.ts

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { invariant } from "~/core/invariant";
+
+export function is_command_available(command: string) {
+  const PATH = process.env.PATH;
+
+  invariant(PATH, "PATH env must exist");
+
+  const path_list = PATH.split(path.delimiter);
+
+  for (const dir of path_list) {
+    const full_path = path.join(dir, command);
+    if (fs.existsSync(full_path)) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/core/is_finite_value.ts

@@ -0,0 +1,3 @@
+export function is_finite_value(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}

package/src/core/json.ts

@@ -0,0 +1,32 @@
+export function serialize(obj: any): any {
+  if (obj instanceof Map) {
+    return {
+      _type: "Map",
+      _value: Array.from(obj.entries()).map(([k, v]) => [k, serialize(v)]),
+    };
+  } else if (Array.isArray(obj)) {
+    return obj.map(serialize);
+  } else if (obj !== null && typeof obj === "object") {
+    const serializedObj: any = {};
+    for (const [key, value] of Object.entries(obj)) {
+      serializedObj[key] = serialize(value);
+    }
+    return serializedObj;
+  }
+  return obj;
+}
+
+export function deserialize(obj: any): any {
+  if (obj && obj._type === "Map") {
+    return new Map(obj._value.map(([k, v]: [any, any]) => [k, deserialize(v)]));
+  } else if (Array.isArray(obj)) {
+    return obj.map(deserialize);
+  } else if (obj !== null && typeof obj === "object") {
+    const deserializedObj: any = {};
+    for (const [key, value] of Object.entries(obj)) {
+      deserializedObj[key] = deserialize(value);
+    }
+    return deserializedObj;
+  }
+  return obj;
+}

package/src/core/match_group.ts

@@ -0,0 +1,10 @@
+import { invariant } from "~/core/invariant";
+
+export function match_group(value: string, re: RegExp, group: string) {
+  const match = value.match(re);
+  const debug = `[${value}.match(${re})]`;
+  invariant(match?.groups, `match.groups must exist ${debug}`);
+  const result = match?.groups[group];
+  invariant(result, `match.groups must contain [${group}] ${debug}`);
+  return result;
+}

package/src/core/read_json.ts

@@ -0,0 +1,12 @@
+import fs from "node:fs";
+
+export function read_json<T = unknown>(path: string): null | T {
+  try {
+    const file_buffer = fs.readFileSync(path);
+    const json_str = String(file_buffer);
+    const json = JSON.parse(json_str);
+    return json;
+  } catch (error) {
+    return null;
+  }
+}

package/src/core/safe_quote.ts

@@ -0,0 +1,10 @@
+// escape double-quote for cli
+export function safe_quote(value: string) {
+  let result = value;
+  result = result.replace(RE.all_double_quote, '\\"');
+  return result;
+}
+
+const RE = {
+  all_double_quote: /"/g,
+};

package/src/core/semver_compare.ts

@@ -0,0 +1,27 @@
+// returns +1 if version_a is greater than version_b
+// returns -1 if version_a is less than version_b
+// returns +0 if version_a is exactly equal to version_b
+//
+// Examples
+//
+//   semver_compare("0.1.1", "0.0.2"); //  1
+//   semver_compare("1.0.1", "0.0.2"); //  1
+//   semver_compare("0.0.1", "1.0.2"); // -1
+//   semver_compare("0.0.1", "0.1.2"); // -1
+//   semver_compare("1.0.1", "1.0.1"); //  0
+//
+export function semver_compare(version_a: string, version_b: string) {
+  const split_a = version_a.split(".").map(Number);
+  const split_b = version_b.split(".").map(Number);
+
+  const max_split_parts = Math.max(split_a.length, split_b.length);
+  for (let i = 0; i < max_split_parts; i++) {
+    const num_a = split_a[i] || 0;
+    const num_b = split_b[i] || 0;
+
+    if (num_a > num_b) return 1;
+    if (num_a < num_b) return -1;
+  }
+
+  return 0;
+}