git-stack-cli 1.8.3 → 1.9.0

package/dist/cjs/index.cjs

@@ -26198,6 +26198,7 @@ function LogTimestamp() {
 
 const BaseStore = createStore()(immer((set, get) => ({
     // set immediately in `index.tsx` so no `null` scenario
+    process_argv: [],
     argv: {},
     ink: {},
     cwd: "",
@@ -27178,9 +27179,9 @@ function format_time(date) {
 }
 
 function GithubApiError() {
-    return reactExports.createElement(Await, { fallback: null, function: run$5 });
+    return reactExports.createElement(Await, { fallback: null, function: run$7 });
 }
-async function run$5() {
+async function run$7() {
     const actions = Store.getState().actions;
     const res = await cli(`gh api https://api.github.com/rate_limit`);
     const res_json = JSON.parse(res.stdout);
@@ -27228,15 +27229,14 @@ const RE$2 = {
 
 function write$1(message, values) {
     let result = message;
-    // escape double-quote for cli
-    result = safe_quote(result);
     // remove any previous metadata lines
     result = remove(result);
     const line_list = [result, "", TEMPLATE$1.stack_id(values.id)];
     if (values.title) {
         line_list.push(TEMPLATE$1.group_title(values.title));
     }
-    const new_message = line_list.join("\n");
+    let new_message = line_list.join("\n");
+    new_message = safe_quote(new_message);
     return new_message;
 }
 function read(message) {
@@ -27269,7 +27269,8 @@ const TEMPLATE$1 = {
     },
 };
 const RE$1 = {
-    stack_id: new RegExp(TEMPLATE$1.stack_id("(?<id>[a-z0-9-+=]+)"), "i"),
+    // https://regex101.com/r/wLmGVq/1
+    stack_id: new RegExp(`${TEMPLATE$1.stack_id("(?<id>[^\\s]+)")}`, "i"),
     group_title: new RegExp(TEMPLATE$1.group_title("(?<title>[^\\n^\\r]+)"), "i"),
 };
 
@@ -27515,17 +27516,33 @@ async function range(commit_group_map) {
 }
 async function get_commit_list() {
     const master_branch = Store.getState().master_branch;
+    const branch_name = Store.getState().branch_name;
+    invariant(branch_name, "branch_name must exist");
     const log_result = await cli(`git log ${master_branch}..HEAD --oneline --format=%H --color=never`);
     if (!log_result.stdout) {
         return [];
     }
     const sha_list = lines(log_result.stdout).reverse();
     const commit_metadata_list = [];
+    let has_metadata = false;
     for (let i = 0; i < sha_list.length; i++) {
         const sha = sha_list[i];
         const commit_metadata = await commit(sha);
+        if (commit_metadata.branch_id) {
+            has_metadata = true;
+        }
         commit_metadata_list.push(commit_metadata);
     }
+    if (!has_metadata) {
+        // check for pr with matching branch name to initialize group
+        const pr_result = await pr_status(branch_name);
+        if (pr_result) {
+            for (const commit_metadata of commit_metadata_list) {
+                commit_metadata.branch_id = branch_name;
+                commit_metadata.title = pr_result.title;
+            }
+        }
+    }
     return commit_metadata_list;
 }
 async function commit(sha) {
@@ -27648,9 +27665,9 @@ function encode(value) {
 }
 
 function LocalMergeRebase() {
-    return (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow }, "Rebasing commits\u2026"), function: run$4 }));
+    return (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow }, "Rebasing commits\u2026"), function: run$6 }));
 }
-async function run$4() {
+async function run$6() {
     const state = Store.getState();
     const actions = state.actions;
     const branch_name = state.branch_name;
@@ -27819,7 +27836,8 @@ function GitReviseTodo(args) {
             // update git commit message with stack id
             const metadata = { id: group.id, title: group.title };
             const unsafe_message_with_id = write$1(commit.full_message, metadata);
-            const message_with_id = unsafe_message_with_id.replace(/"/g, '\\"');
+            let message_with_id = unsafe_message_with_id;
+            message_with_id = message_with_id.replace(/[^\\]"/g, '\\"');
             // get first 12 characters of commit sha
             const sha = commit.sha.slice(0, 12);
             // generate git revise entry
@@ -27940,9 +27958,9 @@ const RE = {
 };
 
 function ManualRebase() {
-    return (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow }, "Rebasing commits\u2026"), function: run$3 }));
+    return (reactExports.createElement(Await, { fallback: reactExports.createElement(Text, { color: colors.yellow }, "Rebasing commits\u2026"), function: run$5 }));
 }
-async function run$3() {
+async function run$5() {
     const state = Store.getState();
     const actions = state.actions;
     const argv = state.argv;
@@ -28453,9 +28471,9 @@ function get_status_bold(row) {
 }
 
 function PostRebaseStatus() {
-    return reactExports.createElement(Await, { fallback: null, function: run$2 });
+    return reactExports.createElement(Await, { fallback: null, function: run$4 });
 }
-async function run$2() {
+async function run$4() {
     const actions = Store.getState().actions;
     // reset github pr cache before refreshing via commit range below
     actions.reset_pr();
@@ -28485,15 +28503,14 @@ function PreLocalMergeRebase() {
 }
 
 function PreManualRebase() {
-    return reactExports.createElement(Await, { fallback: null, function: run$1 });
+    return reactExports.createElement(Await, { fallback: null, function: run$3 });
 }
-async function run$1() {
+async function run$3() {
     const state = Store.getState();
     const actions = state.actions;
     const repo_root = state.repo_root;
     const argv = state.argv;
     invariant(repo_root, "repo_root must exist");
-    invariant(argv, "argv must exist");
     if (!argv.template) {
         return actions.set((state) => {
             state.step = "manual-rebase";
@@ -28993,9 +29010,9 @@ const SYMBOL = {
 };
 
 function Status() {
-    return reactExports.createElement(Await, { fallback: null, function: run });
+    return reactExports.createElement(Await, { fallback: null, function: run$2 });
 }
-async function run() {
+async function run$2() {
     const state = Store.getState();
     const actions = state.actions;
     const argv = state.argv;
@@ -29138,6 +29155,123 @@ function RebaseCheck(props) {
     }
 }
 
+function Fixup() {
+    return reactExports.createElement(Await, { fallback: null, function: run$1 });
+}
+async function run$1() {
+    const state = Store.getState();
+    const actions = state.actions;
+    const argv = state.argv;
+    const relative_number = argv.commit;
+    if (!relative_number) {
+        actions.output(reactExports.createElement(Text, { color: colors.red },
+            "\u2757\uFE0F Usage: git fixup ",
+            "<relative-commit-number>"));
+        actions.output("");
+        actions.output("This script automates the process of adding staged changes as a fixup commit");
+        actions.output("and the subsequent git rebase to flatten the commits based on relative commit number");
+        actions.output("You can use a `git log` like below to get the relative commit number");
+        actions.output("");
+        actions.output("    ❯ git stack log");
+        actions.output("    1\te329794d5f881cbf0fc3f26d2108cf6f3fdebabe enable drop_error_subtask test param");
+        actions.output("    2\t57f43b596e5c6b97bc47e2a591f82ccc81651156 test drop_error_subtask baseline");
+        actions.output("    3\t838e878d483c6a2d5393063fc59baf2407225c6d ErrorSubtask test baseline");
+        actions.output("");
+        actions.output("To target `838e87` above, you would call `fixup 3`");
+        actions.exit(0);
+    }
+    const diff_staged_cmd = await cli("git diff --cached --quiet", {
+        ignoreExitCode: true,
+    });
+    if (!diff_staged_cmd.code) {
+        actions.error("🚨 Stage changes before calling fixup");
+        actions.exit(1);
+        // actions.output(
+        //   <Ink.Text color={colors.red}>
+        //     ❗️ Usage: git fixup {"<relative-commit-number>"}
+        //   </Ink.Text>
+        // );
+    }
+    // Calculate commit SHA based on the relative commit number
+    const adjusted_number = Number(relative_number) - 1;
+    // get the commit SHA of the target commit
+    const commit_sha = (await cli(`git rev-parse HEAD~${adjusted_number}`))
+        .stdout;
+    await cli(`git commit --fixup ${commit_sha}`);
+    // check if stash required
+    let save_stash = false;
+    const diff_cmd = await cli("git diff-index --quiet HEAD --", {
+        ignoreExitCode: true,
+    });
+    if (diff_cmd.code) {
+        save_stash = true;
+        await cli("git stash -q");
+        actions.output(reactExports.createElement(Text, null, "\uD83D\uDCE6 Changes saved to stash"));
+    }
+    // rebase target needs to account for new commit created above
+    const rebase_target = Number(relative_number) + 1;
+    await cli(`git rebase -i --autosquash HEAD~${rebase_target}`, {
+        env: {
+            PATH: process.env.PATH,
+            GIT_EDITOR: "true",
+        },
+    });
+    actions.output(reactExports.createElement(FormatText, { wrapper: reactExports.createElement(Text, { color: colors.yellow }), message: "\uD83D\uDEE0\uFE0F fixup {relative_number} {commit_sha}", values: {
+            commit_sha: reactExports.createElement(Parens, null, commit_sha),
+            relative_number: relative_number,
+        } }));
+    if (save_stash) {
+        await cli("git stash pop -q");
+        actions.output(reactExports.createElement(Text, { color: colors.green }, "\u2705 Changes restored from stash"));
+    }
+}
+
+function Log() {
+    const { stdout } = useStdout();
+    const available_width = stdout.columns || 80;
+    return reactExports.createElement(Await, { fallback: null, function: () => run({ available_width }) });
+}
+async function run(args) {
+    const state = Store.getState();
+    const actions = state.actions;
+    const process_argv = state.process_argv;
+    invariant(actions, "actions must exist");
+    // estimate the number of color characters per line
+    // assuming an average of 5 color changes per line and 5 characters per color code
+    const color_buffer = 12 * 5;
+    const truncation_width = args.available_width + color_buffer;
+    // get the number of characters in the short sha for this repo
+    const short_sha = (await cli(`git log -1 --format=%h`)).stdout.trim();
+    const short_sha_length = short_sha.length + 1;
+    // SHA hash - At least 9 characters wide, truncated
+    const sha_format = `%C(green)%<(${short_sha_length},trunc)%h`;
+    // relative commit date - 15 characters wide, truncated
+    const date_format = `%C(white)%<(15,trunc)%cr`;
+    // author's abbreviated name - 12 characters wide, truncated
+    const author_format = `%C(white)%<(8,trunc)%al`;
+    // decorative information like branch heads or tags
+    const decoration_format = `%C(auto)%d`;
+    // commit subject - 80 characters wide, truncated
+    const subject_format = `%<(60,trunc)%s`;
+    // combine all the above formats into one
+    const format = [
+        sha_format,
+        date_format,
+        author_format,
+        decoration_format,
+        subject_format,
+    ].join(" ");
+    // view the SHA, description and history graph of last 20 commits
+    const rest_args = process_argv.slice(3).join(" ");
+    const command = [
+        `git log --pretty=format:"${format}" -n20 --graph --color ${rest_args}`,
+        `cut -c 1-"${truncation_width}"`,
+        `nl -w3 -s' '`,
+    ].join(" | ");
+    const result = await cli(command);
+    actions.output(result.stdout);
+}
+
 function App() {
     const actions = Store.useActions();
     const ink = Store.useState((state) => state.ink);
@@ -29162,13 +29296,24 @@ function App() {
                 }
             } },
             reactExports.createElement(DependencyCheck, null,
-                reactExports.createElement(DirtyCheck, null,
-                    reactExports.createElement(RebaseCheck, null,
-                        reactExports.createElement(CherryPickCheck, null,
-                            !argv.verbose ? null : reactExports.createElement(GithubApiError, null),
-                            reactExports.createElement(GatherMetadata, null,
-                                reactExports.createElement(LocalCommitStatus, null,
-                                    reactExports.createElement(Main, null))))))))));
+                reactExports.createElement(RebaseCheck, null,
+                    reactExports.createElement(CherryPickCheck, null,
+                        reactExports.createElement(MaybeMain, null)))))));
+}
+function MaybeMain() {
+    const argv = Store.useState((state) => state.argv);
+    const positional_list = new Set(argv["_"]);
+    if (positional_list.has("fixup")) {
+        return reactExports.createElement(Fixup, null);
+    }
+    else if (positional_list.has("log")) {
+        return reactExports.createElement(Log, null);
+    }
+    return (reactExports.createElement(DirtyCheck, null,
+        !argv.verbose ? null : reactExports.createElement(GithubApiError, null),
+        reactExports.createElement(GatherMetadata, null,
+            reactExports.createElement(LocalCommitStatus, null,
+                reactExports.createElement(Main, null)))));
 }
 
 const align = {
@@ -34476,32 +34621,60 @@ const Yargs = YargsFactory(shim$1);
 
 async function command() {
     // https://yargs.js.org/docs/#api-reference-optionkey-opt
-    return (Yargs(hideBin(process.argv))
-        .usage("Usage: git stack [options]")
-        .option("force", {
+    return Yargs(hideBin(process.argv))
+        .usage("Usage: git stack [command] [options]")
+        .command("$0", "Sync commit ranges to Github", (yargs) => yargs.options(DefaultOptions))
+        .command("fixup [commit]", "Amend staged changes to a specific commit in history", (yargs) => yargs.positional("commit", FixupOptions.commit))
+        .command("log [args...]", "Print an abbreviated log with numbered commits, useful for git stack fixup", (yargs) => yargs.strict(false))
+        .option("verbose", GlobalOptions.verbose)
+        // yargs default wraps to 80 columns
+        // passing null will wrap to terminal width
+        // value below if what seems to look decent
+        .wrap(123)
+        // disallow unknown options
+        .strict()
+        .version("1.9.0" )
+        .showHidden("show-hidden", "Show hidden options via `git stack help --show-hidden`")
+        .help("help", "Show usage via `git stack help`")
+        .argv;
+}
+const Rebase = Object.freeze({
+    "git-revise": "git-revise",
+    "cherry-pick": "cherry-pick",
+});
+const GlobalOptions = {
+    verbose: {
+        type: "boolean",
+        alias: ["v"],
+        default: false,
+        description: "Print more detailed logs for debugging internals",
+    },
+};
+const DefaultOptions = {
+    "force": {
         type: "boolean",
         alias: ["f"],
         default: false,
         description: "Force sync even if no changes are detected",
-    })
-        .option("check", {
+    },
+    "check": {
         type: "boolean",
         alias: ["c"],
         default: false,
         description: "Print status table and exit without syncing",
-    })
-        .option("sync", {
+    },
+    "sync": {
         type: "boolean",
         alias: ["s"],
         default: true,
         description: "Sync commit ranges to Github, disable with --no-sync",
-    })
-        .option("verify", {
+    },
+    "verify": {
         type: "boolean",
         default: true,
         description: "Run git hooks such as pre-commit and pre-push, disable with --no-verify",
-    })
-        .option("rebase", {
+    },
+    "rebase": {
         type: "string",
         choices: [Rebase["git-revise"], Rebase["cherry-pick"]],
         default: Rebase["git-revise"],
@@ -34510,67 +34683,59 @@ async function command() {
             `${Rebase["git-revise"]}: perform faster in-memory rebase`,
             `${Rebase["cherry-pick"]}: use disk and incrementally rebase each commit`,
         ].join(" | "),
-    })
-        .option("verbose", {
-        type: "boolean",
-        alias: ["v"],
-        default: false,
-        description: "Print more detailed logs for debugging internals",
-    })
-        .option("update", {
+    },
+    "update": {
         type: "boolean",
         alias: ["u", "upgrade"],
         default: false,
         description: "Check and install the latest version",
-    })
-        .option("branch", {
+    },
+    "branch": {
         type: "string",
         alias: ["b"],
         description: 'Set the master branch name, defaults to "master" (or "main" if "master" is not found)',
-    })
-        .option("draft", {
+    },
+    "draft": {
         type: "boolean",
         alias: ["d"],
         default: false,
         description: "Open all PRs as drafts",
-    })
-        .option("write-state-json", {
+    },
+    "write-state-json": {
         hidden: true,
         type: "boolean",
         default: false,
         description: "Write state to local json file for debugging",
-    })
-        .option("template", {
+    },
+    "template": {
         type: "boolean",
         default: true,
         description: "Use automatic Github PR template, e.g. .github/pull_request_template.md, disable with --no-template",
-    })
-        .option("mock-metadata", {
+    },
+    "mock-metadata": {
         hidden: true,
         type: "boolean",
         default: false,
         description: "Mock local store metadata for testing",
-    })
-        // yargs default wraps to 80 columns
-        // passing null will wrap to terminal width
-        // value below if what seems to look decent
-        .wrap(123)
-        // disallow unknown options
-        .strict()
-        .version("1.8.3" )
-        .showHidden("show-hidden", "Show hidden options via `git stack help --show-hidden`")
-        .help("help", "Show usage via `git stack help`").argv);
-}
-const Rebase = Object.freeze({
-    "git-revise": "git-revise",
-    "cherry-pick": "cherry-pick",
-});
+    },
+};
+const FixupOptions = {
+    commit: {
+        type: "number",
+        default: 1,
+        description: [
+            "Relative number of commit to amend staged changes.",
+            "Most recent is 1, next is 2, etc.",
+        ].join("\n"),
+    },
+};
 
 command()
     .then((argv) => {
     const ink = render(reactExports.createElement(App, null));
     Store.setState((state) => {
         state.ink = ink;
+        state.process_argv = process.argv;
         state.argv = argv;
         state.cwd = process.cwd();
     });

package/package.json

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

package/src/app/App.tsx

@@ -13,6 +13,8 @@ import { Output } from "~/app/Output";
 import { Providers } from "~/app/Providers";
 import { RebaseCheck } from "~/app/RebaseCheck";
 import { Store } from "~/app/Store";
+import { Fixup } from "~/commands/Fixup";
+import { Log } from "~/commands/Log";
 
 export function App() {
   const actions = Store.useActions();
@@ -51,21 +53,36 @@ export function App() {
         }}
       >
         <DependencyCheck>
-          <DirtyCheck>
-            <RebaseCheck>
-              <CherryPickCheck>
-                {!argv.verbose ? null : <GithubApiError />}
-
-                <GatherMetadata>
-                  <LocalCommitStatus>
-                    <Main />
-                  </LocalCommitStatus>
-                </GatherMetadata>
-              </CherryPickCheck>
-            </RebaseCheck>
-          </DirtyCheck>
+          <RebaseCheck>
+            <CherryPickCheck>
+              <MaybeMain />
+            </CherryPickCheck>
+          </RebaseCheck>
         </DependencyCheck>
       </AutoUpdate>
     </Providers>
   );
 }
+function MaybeMain() {
+  const argv = Store.useState((state) => state.argv);
+
+  const positional_list = new Set(argv["_"]);
+
+  if (positional_list.has("fixup")) {
+    return <Fixup />;
+  } else if (positional_list.has("log")) {
+    return <Log />;
+  }
+
+  return (
+    <DirtyCheck>
+      {!argv.verbose ? null : <GithubApiError />}
+
+      <GatherMetadata>
+        <LocalCommitStatus>
+          <Main />
+        </LocalCommitStatus>
+      </GatherMetadata>
+    </DirtyCheck>
+  );
+}

package/src/app/PreManualRebase.tsx

@@ -23,7 +23,6 @@ async function run() {
   const argv = state.argv;
 
   invariant(repo_root, "repo_root must exist");
-  invariant(argv, "argv must exist");
 
   if (!argv.template) {
     return actions.set((state) => {

package/src/app/Store.tsx

@@ -26,6 +26,7 @@ type MutateOutputArgs = {
 
 export type State = {
   // set immediately in `index.tsx` so no `null` scenario
+  process_argv: Array<string>;
   argv: Argv;
   ink: InkInstance;
   cwd: string;
@@ -89,6 +90,7 @@ export type State = {
 const BaseStore = createStore<State>()(
   immer((set, get) => ({
     // set immediately in `index.tsx` so no `null` scenario
+    process_argv: [],
     argv: {} as Argv,
     ink: {} as InkInstance,
     cwd: "",