git-stack-cli 0.7.4 → 0.7.6

package/README.md

@@ -1,13 +1,15 @@
 # git-stack-cli
 
+- ✨ **[Stacked diffs](https://graphite.dev/guides/stacked-diffs) for `git`**
 - 🚀 **Simple one-branch workflow**
 - 🎯 **Interactively select commits for each pull request**
-- 📚 **Preserve your detailed commit history**
-- ♻️ **Automatically synchronize each pull request in the stack**
 - 💬 **Group commits for focused code review**
-- 🚫 **Avoid mutiple branch juggling and complex rebasing**
+- 🌐 **Use the [official GitHub CLI](https://cli.github.com/)**
+- ♻️ **Automatically synchronize each pull request in the stack**
 - 💪 **Work seamlessly with GitHub's interface**
-- 🌐 **Leverage the [official GitHub CLI](https://cli.github.com/)**
+- 🚫 **Avoid juggling mutiple branches and complex rebasing**
+- 📚 **Preserve your detailed commit history**
+
 
 ## Demo
 
@@ -17,10 +19,19 @@
 
 ```bash
 npm i -g git-stack-cli
+```
 
+## Usage
+
+
+```bash
 git stack
-```
 
+git stack --verbose   # print more detailed logs for debugging internals
+git stack --no-verify # skip git hooks such as pre-commit and pre-push
+
+git-stack --help      # print a table of all command-line arguments
+```
 
 ## Why?
 

package/dist/app/DependencyCheck.js

@@ -16,6 +16,10 @@ export function DependencyCheck(props) {
             "Checking ",
             React.createElement(Command, null, "git"),
             " install..."), function: async () => {
+            // await Promise.all([
+            //   cli(`for i in $(seq 1 5); do echo $i; sleep 1; done`),
+            //   cli(`for i in $(seq 5 1); do printf "$i "; sleep 1; done; echo`),
+            // ]);
             if (is_command_available("git")) {
                 return;
             }

package/dist/app/LocalMergeRebase.js

@@ -17,9 +17,11 @@ export function LocalMergeRebase() {
 async function run() {
     const state = Store.getState();
     const actions = state.actions;
+    const argv = state.argv;
     const branch_name = state.branch_name;
     const commit_range = state.commit_range;
     const master_branch = state.master_branch;
+    invariant(argv, "argv must exist");
     invariant(branch_name, "branch_name must exist");
     invariant(commit_range, "commit_range must exist");
     // always listen for SIGINT event and restore git state
@@ -51,7 +53,22 @@ async function run() {
                         commit_message: React.createElement(Brackets, null, commit.message),
                     } }));
             }
-            await cli(`git cherry-pick ${commit.sha}`);
+            await cli(`git format-patch -1 ${commit.sha} --stdout > ${PATCH_FILE}`);
+            await cli(`git apply ${PATCH_FILE}`);
+            await cli(`rm ${PATCH_FILE}`);
+            await cli(`git add --all`);
+            let new_message;
+            if (commit.branch_id) {
+                new_message = await Metadata.write(commit.message, commit.branch_id);
+            }
+            else {
+                new_message = commit.message;
+            }
+            const git_commit_comand = [`git commit -m "${new_message}"`];
+            if (argv.verify === false) {
+                git_commit_comand.push("--no-verify");
+            }
+            await cli(git_commit_comand);
             if (commit.branch_id && !commit_pr) {
                 if (actions.isDebug()) {
                     actions.output(React.createElement(FormatText, { wrapper: React.createElement(Ink.Text, { color: colors.yellow, wrap: "truncate-end" }), message: "Cleaning up unused group {group}", values: {
@@ -89,6 +106,8 @@ async function run() {
         // trying to use `await cli(...)` here will silently fail since
         // all children processes receive the SIGINT signal
         const spawn_options = { ignoreExitCode: true };
+        // always clean up any patch files
+        cli.sync(`rm ${PATCH_FILE}`, spawn_options);
         // always put self back in original branch
         cli.sync(`git checkout ${branch_name}`, spawn_options);
         // ...and cleanup temporary branch
@@ -113,3 +132,4 @@ async function run() {
         actions.exit(6);
     }
 }
+const PATCH_FILE = "mypatch.patch";

package/dist/app/ManualRebase.js

@@ -57,11 +57,16 @@ async function run(props) {
             const selected_url = get_group_url(group);
             // cherry-pick and amend commits one by one
             for (const commit of group.commits) {
-                await cli(`git cherry-pick ${commit.sha}`);
-                if (commit.branch_id !== group.id) {
-                    const new_message = await Metadata.write(commit.message, group.id);
-                    await cli(`git commit --amend -m "${new_message}"`);
+                await cli(`git format-patch -1 ${commit.sha} --stdout > ${PATCH_FILE}`);
+                await cli(`git apply ${PATCH_FILE}`);
+                await cli(`rm ${PATCH_FILE}`);
+                await cli(`git add --all`);
+                const new_message = await Metadata.write(commit.message, group.id);
+                const git_commit_comand = [`git commit -m "${new_message}"`];
+                if (argv.verify === false) {
+                    git_commit_comand.push("--no-verify");
                 }
+                await cli(git_commit_comand);
             }
             actions.output(React.createElement(FormatText, { wrapper: React.createElement(Ink.Text, { color: colors.yellow, wrap: "truncate-end" }), message: "Syncing {group}\u2026", values: {
                     group: (React.createElement(Brackets, null, group.pr?.title || group.title || group.id)),
@@ -72,7 +77,7 @@ async function run(props) {
                 if (argv.verify === false) {
                     git_push_command.push("--no-verify");
                 }
-                await cli(git_push_command.join(" "));
+                await cli(git_push_command);
                 if (group.pr) {
                     // ensure base matches pr in github
                     await github.pr_edit({
@@ -160,6 +165,8 @@ async function run(props) {
         // trying to use `await cli(...)` here will silently fail since
         // all children processes receive the SIGINT signal
         const spawn_options = { ignoreExitCode: true };
+        // always clean up any patch files
+        cli.sync(`rm ${PATCH_FILE}`, spawn_options);
         // always put self back in original branch
         cli.sync(`git checkout ${branch_name}`, spawn_options);
         // ...and cleanup temporary branch
@@ -185,3 +192,4 @@ async function run(props) {
     }
 }
 const get_group_url = (group) => group.pr?.url || group.id;
+const PATCH_FILE = "mypatch.patch";

package/dist/app/Output.js

@@ -3,7 +3,17 @@ import * as Ink from "ink";
 import { Store } from "./Store.js";
 export function Output() {
     const output = Store.useState((state) => state.output);
-    return (React.createElement(Ink.Static, { items: output }, (node, i) => {
-        return React.createElement(Ink.Box, { key: i }, node);
-    }));
+    const pending_output = Store.useState((state) => state.pending_output);
+    const pending_output_items = Object.values(pending_output);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Ink.Static, { items: output }, (node, i) => {
+            return React.createElement(Ink.Box, { key: i }, node);
+        }),
+        pending_output_items.map((node_list, i) => {
+            return (React.createElement(Ink.Box, { key: i },
+                React.createElement(Ink.Text, null, node_list.map((text, j) => {
+                    return (React.createElement(React.Fragment, { key: j },
+                        React.createElement(Ink.Text, null, text)));
+                }))));
+        })));
 }

package/dist/app/Store.js

@@ -18,11 +18,13 @@ const BaseStore = createStore()(immer((set, get) => ({
     commit_map: null,
     step: "loading",
     output: [],
+    pending_output: {},
     pr: {},
     actions: {
         exit(code, clear = true) {
             set((state) => {
-                state.mutate.output(state, React.createElement(Exit, { clear: clear, code: code }));
+                const node = React.createElement(Exit, { clear: clear, code: code });
+                state.mutate.output(state, { node });
             });
         },
         clear() {
@@ -33,28 +35,37 @@ const BaseStore = createStore()(immer((set, get) => ({
         },
         newline() {
             set((state) => {
-                state.mutate.output(state, "‎");
+                const node = "‎";
+                state.mutate.output(state, { node });
             });
         },
         json(value) {
             set((state) => {
-                state.mutate.output(state, JSON.stringify(value, null, 2));
+                const node = JSON.stringify(value, null, 2);
+                state.mutate.output(state, { node });
             });
         },
         error(message) {
             set((state) => {
-                state.mutate.output(state, React.createElement(Ink.Text, { color: colors.red }, message));
+                const node = React.createElement(Ink.Text, { color: colors.red }, message);
+                state.mutate.output(state, { node });
             });
         },
         output(node) {
             set((state) => {
-                state.mutate.output(state, node);
+                state.mutate.output(state, { node });
             });
         },
-        debug(node) {
+        debug(node, id) {
             if (get().actions.isDebug()) {
+                const debug = true;
                 set((state) => {
-                    state.mutate.output(state, React.createElement(Ink.Text, { dimColor: true }, node));
+                    if (id) {
+                        state.mutate.pending_output(state, { id, node, debug });
+                    }
+                    else {
+                        state.mutate.output(state, { node, debug });
+                    }
                 });
             }
         },
@@ -74,15 +85,36 @@ const BaseStore = createStore()(immer((set, get) => ({
         },
     },
     mutate: {
-        output(state, node) {
-            switch (typeof node) {
+        output(state, args) {
+            switch (typeof args.node) {
                 case "boolean":
                 case "number":
                 case "string":
-                    state.output.push(React.createElement(Ink.Text, null, String(node)));
+                    state.output.push(React.createElement(Ink.Text, { dimColor: args.debug }, String(args.node)));
                     return;
             }
-            state.output.push(node);
+            state.output.push(args.node);
+        },
+        pending_output(state, args) {
+            const { id } = args;
+            if (!id) {
+                return;
+            }
+            if (!state.pending_output[id]) {
+                state.pending_output[id] = [];
+            }
+            switch (typeof args.node) {
+                case "boolean":
+                case "number":
+                case "string": {
+                    state.pending_output[id].push(React.createElement(Ink.Text, { dimColor: args.debug }, String(args.node)));
+                    return;
+                }
+            }
+            state.pending_output[id].push(args.node);
+        },
+        end_pending_output(state, id) {
+            delete state.pending_output[id];
         },
     },
     select: {

package/dist/command.js

@@ -19,13 +19,13 @@ export async function command() {
         .option("verify", {
         type: "boolean",
         default: true,
-        description: "Disable the pre-push hook, bypassing it completely",
+        description: "Skip git hooks such as pre-commit and pre-push",
     })
         .option("verbose", {
         type: "boolean",
         alias: ["v"],
         default: false,
-        description: "Enable verbose mode with more detailed output for debugging",
+        description: "Print more detailed logs for debugging internals",
     })
         .option("branch", {
         type: "string",

package/dist/core/cli.js

@@ -1,35 +1,53 @@
 import * as child from "node:child_process";
 import { Store } from "../app/Store.js";
-export async function cli(command, unsafe_options) {
+let i = 0;
+export async function cli(unsafe_command, unsafe_options) {
     const state = Store.getState();
     const options = Object.assign({}, unsafe_options);
+    let command;
+    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(`[start] ${command}`);
+        state.actions.debug(`[start] ${command}\n`, id);
+        function write_output(value) {
+            output += value;
+            state.actions.debug(value, id);
+        }
         childProcess.stdout?.on("data", (data) => {
-            stdout += data.toString();
-            output += data.toString();
+            const value = String(data);
+            stdout += value;
+            write_output(value);
         });
         childProcess.stderr?.on("data", (data) => {
-            stderr += data.toString();
-            output += data.toString();
+            const value = String(data);
+            stderr += value;
+            write_output(value);
         });
         childProcess.on("close", (code) => {
+            const result = {
+                command,
+                code: code || 0,
+                stdout: stdout.trimEnd(),
+                stderr: stderr.trimEnd(),
+                output: output.trimEnd(),
+            };
+            state.actions.set((state) => state.mutate.end_pending_output(state, id));
+            state.actions.debug(`[end] ${command}`);
+            state.actions.debug(result.output);
             if (!options.ignoreExitCode && code !== 0) {
                 reject(new Error(`[${command}] (${code})`));
             }
             else {
-                const result = {
-                    command,
-                    code: code || 0,
-                    stdout: stdout.trimEnd(),
-                    stderr: stderr.trimEnd(),
-                    output: output.trimEnd(),
-                };
-                state.actions.debug(`$ ${command}`);
-                state.actions.debug(result.output);
                 resolve(result);
             }
         });

package/package.json

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