git-stack-cli 2.8.0 → 2.8.2

package/package.json

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

package/scripts/release-npm.ts

@@ -6,6 +6,9 @@ import { spawn } from "~/core/spawn";
 
 process.env.NODE_ENV = "production";
 
+// ensure npm is authenticated
+await spawn(`npm whoami`);
+
 // get paths relative to this script
 const REPO_ROOT = (await spawn.sync("git rev-parse --show-toplevel")).stdout;
 const DIST_DIR = path.join(REPO_ROOT, "dist");
@@ -54,9 +57,6 @@ for (const filepath of package_json.files) {
   }
 }
 
-// ensure npm is authenticated
-await spawn(`npm whoami`);
-
 process.chdir(REPO_ROOT);
 
 await spawn.sync(`git commit -a -m ${version}`);

package/src/app/GatherMetadata.test.tsx

@@ -0,0 +1,33 @@
+import { test, expect } from "bun:test";
+
+import * as GatherMetadata from "~/app/GatherMetadata";
+
+test("invalid origin", () => {
+  const origin_url = "";
+  const repo_path = GatherMetadata.get_repo_path(origin_url);
+  expect(repo_path).toBe(null);
+});
+
+test("https .git", () => {
+  const origin_url = "https://github.com/magus/git-multi-diff-playground.git";
+  const repo_path = GatherMetadata.get_repo_path(origin_url);
+  expect(repo_path).toBe("magus/git-multi-diff-playground");
+});
+
+test("https without .git", () => {
+  const origin_url = "https://github.com/magus/git-multi-diff-playground";
+  const repo_path = GatherMetadata.get_repo_path(origin_url);
+  expect(repo_path).toBe("magus/git-multi-diff-playground");
+});
+
+test("git@ .git", () => {
+  const origin_url = "git@github.com:magus/git-multi-diff-playground.git";
+  const repo_path = GatherMetadata.get_repo_path(origin_url);
+  expect(repo_path).toBe("magus/git-multi-diff-playground");
+});
+
+test("git@ without .git", () => {
+  const origin_url = "git@github.com:magus/git-multi-diff-playground";
+  const repo_path = GatherMetadata.get_repo_path(origin_url);
+  expect(repo_path).toBe("magus/git-multi-diff-playground");
+});

package/src/app/GatherMetadata.tsx

@@ -97,10 +97,21 @@ async function run() {
   }
 }
 
+export function get_repo_path(origin_url: string): null | string {
+  try {
+    return match_group(origin_url, RE.repo_path, "repo_path");
+  } catch {
+    // pass
+  }
+  return null;
+}
+
 const RE = {
   // git@github.com:magus/git-multi-diff-playground.git
   // https://github.com/magus/git-multi-diff-playground.git
-  repo_path: /(?<repo_path>[^:^/]+\/[^/]+)\.git/,
+  // the .git suffix is optional for remote urls, and may not always be provided
+  // https://regex101.com/r/pICG7G/1
+  repo_path: /(?<repo_path>[^:^/]+\/[^/]+?)(\.git)?$/,
 };
 
 const BRANCH = {

package/src/app/PreManualRebase.tsx

@@ -39,10 +39,11 @@ async function run() {
   // ./pull_request_template.md
   // ./docs/pull_request_template.md
   for (const key of PR_TEMPLATE_KEY_LIST) {
-    const pr_template_fn = PR_TEMPLATE[key as keyof typeof PR_TEMPLATE];
+    const pr_template_fn = PR_TEMPLATE[key];
+    const pr_template_file = pr_template_fn(repo_root);
 
-    if (await safe_exists(pr_template_fn(repo_root))) {
-      pr_template_body = await fs.readFile(pr_template_fn(repo_root), "utf-8");
+    if (await safe_exists(pr_template_file)) {
+      pr_template_body = await fs.readFile(pr_template_file, "utf-8");
 
       actions.output(
         <FormatText
@@ -58,10 +59,23 @@ async function run() {
     }
   }
 
-  // ./.github/PULL_REQUEST_TEMPLATE/*.md
   let pr_templates: Array<string> = [];
-  if (await safe_exists(PR_TEMPLATE.TemplateDir(repo_root))) {
-    pr_templates = await fs.readdir(PR_TEMPLATE.TemplateDir(repo_root));
+  let pr_dir: string = "";
+
+  // ./.github/PULL_REQUEST_TEMPLATE/*.md
+  pr_dir = PR_TEMPLATE.DirGithub(repo_root);
+  if (await safe_exists(pr_dir)) {
+    for (const filename of await fs.readdir(pr_dir)) {
+      pr_templates.push(path.join(pr_dir, filename));
+    }
+  }
+
+  // ./docs/PULL_REQUEST_TEMPLATE/*.md
+  pr_dir = PR_TEMPLATE.DirDocs(repo_root);
+  if (await safe_exists(pr_dir)) {
+    for (const filename of await fs.readdir(pr_dir)) {
+      pr_templates.push(path.join(pr_dir, filename));
+    }
   }
 
   // check if repo has multiple pr templates
@@ -71,14 +85,20 @@ async function run() {
 
     if (pr_templates.length > 0) {
       actions.output(
-        <FormatText
-          wrapper={<Ink.Text color={colors.yellow} />}
-          message="{count} queryable templates found under {dir}, but not supported."
-          values={{
-            count: <Ink.Text color={colors.blue}>{pr_templates.length}</Ink.Text>,
-            dir: <Brackets>{PR_TEMPLATE.TemplateDir("")}</Brackets>,
-          }}
-        />,
+        <Ink.Box flexDirection="column">
+          {pr_templates.map((filepath) => {
+            const relpath = path.relative(repo_root, filepath);
+            return <Ink.Text key={filepath}>- {relpath}</Ink.Text>;
+          })}
+
+          <FormatText
+            wrapper={<Ink.Text color={colors.yellow} />}
+            message="{count} queryable templates found, but not supported."
+            values={{
+              count: <Ink.Text color={colors.blue}>{pr_templates.length}</Ink.Text>,
+            }}
+          />
+        </Ink.Box>,
       );
     }
 
@@ -91,8 +111,11 @@ const PR_TEMPLATE = Object.freeze({
   Github: (root: string) => path.join(root, ".github", "pull_request_template.md"),
   Root: (root: string) => path.join(root, "pull_request_template.md"),
   Docs: (root: string) => path.join(root, "docs", "pull_request_template.md"),
-  TemplateDir: (root: string) => path.join(root, ".github", "PULL_REQUEST_TEMPLATE"),
+
+  DirDocs: (root: string) => path.join(root, "docs", "PULL_REQUEST_TEMPLATE/"),
+  DirGithub: (root: string) => path.join(root, ".github", "PULL_REQUEST_TEMPLATE/"),
 });
 
 // prettier-ignore
-const PR_TEMPLATE_KEY_LIST = Object.keys(PR_TEMPLATE) as Array<keyof typeof PR_TEMPLATE>;
+//
+const PR_TEMPLATE_KEY_LIST = ["Github", "Root", "Docs"] satisfies Array<keyof typeof PR_TEMPLATE>;

package/src/app/SyncGithub.tsx

@@ -75,12 +75,15 @@ async function run() {
 
     const git_push_target_list: Array<string> = [];
 
-    for (const group of push_group_list) {
+    for (let i = 0; i < push_group_list.length; i++) {
+      const group = push_group_list[i];
       const last_commit = last(group.commits);
       invariant(last_commit, "last_commit must exist");
 
       // push group in isolation if master_base is set
-      if (group.master_base) {
+      // for the first group (i > 0) we can skip this
+      // since it'll be based off master anyway
+      if (group.master_base && i > 0) {
         await push_master_group(group);
         continue;
       }
@@ -237,8 +240,6 @@ async function run() {
       if (!is_master_base(group)) {
         // ensure base matches pr in github
         await github.pr_edit({ branch: group.id, base: group.base });
-      } else {
-        await github.pr_edit({ branch: group.id });
       }
     } else {
       // create pr in github

package/src/core/CommitMetadata.ts

@@ -121,6 +121,7 @@ export async function range(commit_group_map?: CommitGroupMap) {
 
   for (let i = 0; i < group_value_list.length; i++) {
     const group = group_value_list[i];
+    const previous_group: undefined | CommitGroup = group_value_list[i - 1];
 
     if (group.id !== UNASSIGNED) {
       let pr_result = pr_lookup[group.id];
@@ -164,29 +165,61 @@ export async function range(commit_group_map?: CommitGroupMap) {
 
     if (!group.pr) {
       group.dirty = true;
-    } else if (group.pr.commits.length !== group.commits.length) {
-      group.dirty = true;
-    } else if (group.pr.baseRefName !== group.base) {
-      group.dirty = true;
-    } else if (group.master_base) {
-      group.pr.number;
-      // 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 | pbcopy
-      const diff_github = await github.pr_diff(group.pr.number);
-      const diff_local = await git.get_diff(group.commits);
-      if (diff_github !== diff_local) {
-        group.dirty = true;
-      }
     } else {
-      // comapre literal commit shas in group
-      for (let i = 0; i < group.pr.commits.length; i++) {
-        const pr_commit = group.pr.commits[i];
-        const local_commit = group.commits[i];
+      if (group.pr.baseRefName !== group.base) {
+        group.dirty = true;
+      } else if (group.master_base && i > 0) {
+        // 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
+        const diff_github = await github.pr_diff(group.pr.number);
+        const diff_local = await git.get_diff(group.commits);
+        if (diff_github !== diff_local) {
+          group.dirty = true;
+        }
+      } else if (!group.master_base && previous_group && previous_group.master_base) {
+        // special case
+        // boundary between normal commits and master commits
+
+        // collect all previous groups for sha comparison
+        const all_commits: Array<git.Commit> = [];
+        const previous_groups = group_value_list.slice(0, i);
+        for (const g of previous_groups) {
+          for (const c of g.commits) {
+            all_commits.push(c);
+          }
+        }
+        for (const c of group.commits) {
+          all_commits.push(c);
+        }
 
-        if (pr_commit.oid !== local_commit.sha) {
+        // compare all commits against pr commits
+        if (group.pr.commits.length !== all_commits.length) {
           group.dirty = true;
+        } else {
+          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) {
+              group.dirty = true;
+            }
+          }
+        }
+      } else if (group.pr.commits.length !== group.commits.length) {
+        group.dirty = true;
+      } else {
+        // 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++) {
+          const pr_commit = group.pr.commits[i];
+          const local_commit = group.commits[i];
+
+          if (pr_commit.oid !== local_commit.sha) {
+            group.dirty = true;
+          }
         }
       }
     }

package/src/core/github.tsx

@@ -171,6 +171,10 @@ export async function pr_edit(args: EditPullRequestArgs) {
   // const actions = state.actions;
   // actions.debug(`github.pr_edit ${JSON.stringify(args)}`);
 
+  if (!args.base && !args.body) {
+    return;
+  }
+
   const command_parts = [`gh pr edit ${args.branch}`];
 
   if (args.base) {