git-stack-cli 1.15.1 → 2.0.1-beta

package/package.json

@@ -1,42 +1,42 @@
 {
   "name": "git-stack-cli",
-  "version": "1.15.1",
+  "version": "2.0.1-beta",
   "description": "",
   "author": "magus",
   "license": "MIT",
+  "packageManager": "pnpm@9.15.4+sha512.b2dc20e2fc72b3e18848459b37359a32064663e5627a51e4c74b2c29dd8e8e0491483c3abb40789cfd578bf362fb6ba8261b05f0387d76792ed6e23ea3b1b6a0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/magus/git-stack-cli.git"
   },
   "type": "module",
   "bin": {
-    "git-stack": "dist/cjs/index.cjs"
+    "git-stack": "dist/js/index.js"
   },
   "files": [
-    "dist/cjs",
+    "dist/js",
+    "package.json",
+    "pnpm-lock.yaml",
     "scripts",
     "src",
-    "package-lock.json",
-    "rollup.config.js",
     "tsconfig.json"
   ],
   "scripts": {
-    "dev": "npm run build -- --watch",
-    "build": "rollup -c rollup.config.js",
-    "build:standalone": "GIT_STACK_STANDALONE=true bun run scripts/build-standalone.ts",
-    "link": "bun run scripts/link.ts",
+    "dev": "pnpm run build --watch",
+    "build": "bun run scripts/bun-build.ts",
+    "compile": "bun run scripts/bun-compile.ts",
     "release:npm": "bun run scripts/release-npm.ts",
     "release:github": "bun run scripts/release-github.ts",
     "release:brew": "bun run scripts/release-brew.ts",
-    "release": "npm run release:npm && npm run release:github && npm run release:brew",
+    "release": "pnpm run release:npm && pnpm run release:github && pnpm run release:brew",
     "lint:check": "eslint . --cache",
-    "lint": "npm run lint:check -- --fix",
-    "prettier:check": "prettier ./src --check --cache",
-    "prettier": "npm run prettier:check -- --write",
+    "lint": "pnpm run lint:check --fix",
+    "prettier:check": "prettier src scripts config .eslintrc.cjs --check --cache",
+    "prettier": "pnpm run prettier:check --write",
     "test": "bun test",
-    "test:watch": "npm run test -- --watch",
+    "test:watch": "pnpm run test --watch",
     "test:types": "tsc",
-    "test:all": "npm run prettier:check && npm run lint:check && npm run test:types",
+    "test:all": "pnpm run prettier:check && pnpm run lint:check && pnpm run test:types",
     "prepublishOnly": "bun run scripts/npm-prepublishOnly.ts"
   },
   "dependencies": {
@@ -52,12 +52,6 @@
     "zustand": "^4.4.4"
   },
   "devDependencies": {
-    "@rollup/plugin-alias": "^5.1.0",
-    "@rollup/plugin-commonjs": "^25.0.7",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-replace": "^5.0.5",
-    "@rollup/plugin-typescript": "^11.1.6",
     "@types/chalk": "^2.2.0",
     "@types/lodash": "^4.17.7",
     "@types/luxon": "^3.4.2",
@@ -66,14 +60,13 @@
     "@types/yargs": "^17.0.29",
     "@typescript-eslint/eslint-plugin": "^6.9.0",
     "@typescript-eslint/parser": "^6.9.0",
-    "bun-types": "^1.0.21",
+    "bun": "1.1.44",
+    "bun-types": "1.1.44",
     "eslint": "^8.52.0",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.29.0",
     "eslint-plugin-react": "^7.33.2",
-    "pkg": "^5.8.1",
     "prettier": "^3.0.3",
-    "rollup": "^4.10.0",
     "typescript": "^5.2.2"
   }
 }

package/scripts/bun-build.ts

@@ -0,0 +1,111 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import * as util from "util";
+
+import * as file from "~/core/file";
+import { spawn } from "~/core/spawn";
+
+const parsed_args = util.parseArgs({
+  args: Bun.argv,
+  options: {
+    watch: {
+      type: "boolean",
+      default: false,
+    },
+    verbose: {
+      type: "boolean",
+      default: false,
+    },
+  },
+  strict: true,
+  allowPositionals: true,
+});
+
+const WATCH = parsed_args.values.watch;
+const VERBOSE = parsed_args.values.verbose;
+
+console.debug("📦 bundle", WATCH ? "watch" : "build");
+
+if (VERBOSE) {
+  console.debug(parsed_args);
+}
+
+const REPO_ROOT = (await spawn.sync("git rev-parse --show-toplevel")).stdout;
+
+const PACKAGE_JSON = await file.read_json(path.join(REPO_ROOT, "package.json"));
+const GIT_SEQUENCE_EDITOR_SCRIPT_PATH = path.join(REPO_ROOT, "scripts", "git-sequence-editor.sh");
+const UNSAFE_GIT_SEQUENCE_EDITOR_SCRIPT = await file.read_text(GIT_SEQUENCE_EDITOR_SCRIPT_PATH);
+const GIT_SEQUENCE_EDITOR_SCRIPT = UNSAFE_GIT_SEQUENCE_EDITOR_SCRIPT.replace(/`/g, "\\`");
+
+let GITIGNORE = (await file.read_text(path.join(REPO_ROOT, ".gitignore"))).split("\n");
+GITIGNORE = GITIGNORE.filter((line) => line.trim() && !line.startsWith("#"));
+GITIGNORE.push(".git");
+
+const define = {
+  "process.env.NODE_ENV": JSON.stringify("production"),
+  "process.env.CLI_VERSION": JSON.stringify(String(PACKAGE_JSON.version)),
+  "process.env.GIT_SEQUENCE_EDITOR_SCRIPT": JSON.stringify(GIT_SEQUENCE_EDITOR_SCRIPT),
+};
+
+if (VERBOSE) {
+  console.debug({ define });
+}
+
+async function run_build() {
+  const start = Date.now();
+
+  const result = await Bun.build({
+    entrypoints: ["./src/index.tsx"],
+    outdir: "./dist/js",
+    target: "node",
+    env: "inline",
+    format: "esm",
+    define,
+  });
+
+  const duration_ms = Date.now() - start;
+
+  console.debug(`✅ Build (${duration_ms}ms)`);
+
+  if (VERBOSE) {
+    console.debug({ result });
+  }
+}
+
+if (!WATCH) {
+  await run_build();
+} else {
+  await run_build();
+
+  console.debug("👀 Watching for changes…");
+
+  const { signal } = new AbortController();
+
+  const watcher = fs.watch(REPO_ROOT, { recursive: true, signal });
+  for await (const event of watcher) {
+    const filename = event.filename;
+
+    if (!filename) {
+      continue;
+    }
+
+    // ignore this file
+    if (import.meta.filename == path.join(REPO_ROOT, filename)) {
+      continue;
+    }
+
+    // ignore files in gitignore
+    const ignored = GITIGNORE.some((pattern) => filename.startsWith(pattern));
+    if (ignored) {
+      continue;
+    }
+
+    console.debug(`⚠️ Change ${filename}`);
+
+    if (VERBOSE) {
+      console.debug({ ignored, filename, event });
+    }
+
+    await run_build();
+  }
+}

package/scripts/bun-compile.ts

@@ -0,0 +1,79 @@
+import path from "node:path";
+import * as util from "util";
+
+import * as file from "~/core/file";
+import { spawn } from "~/core/spawn";
+
+const parsed_args = util.parseArgs({
+  args: Bun.argv,
+  options: {
+    target: {
+      type: "string",
+    },
+    verbose: {
+      type: "boolean",
+      default: false,
+    },
+  },
+  strict: true,
+  allowPositionals: true,
+});
+
+const TARGET = parsed_args.values.target;
+const VERBOSE = parsed_args.values.verbose;
+
+console.debug("📦 compile");
+
+if (VERBOSE) {
+  console.debug(parsed_args);
+}
+
+const REPO_ROOT = (await spawn.sync("git rev-parse --show-toplevel")).stdout;
+const DIST_DIR = path.join(REPO_ROOT, "dist");
+const INPUT_JS = path.join(DIST_DIR, "js", "index.js");
+
+if (!(await file.exists(INPUT_JS))) {
+  console.error(`❌ Missing ${path.relative(REPO_ROOT, INPUT_JS)}`);
+  console.debug("Run `pnpm run build` first to generate the input file.");
+  process.exit(12);
+}
+
+if (TARGET) {
+  const target = TARGET;
+  await compile_target({ target });
+  process.exit(0);
+}
+
+const TARGET_LIST = ["bun-linux-x64", "bun-windows-x64", "bun-darwin-arm64", "bun-darwin-x64"];
+
+for (const target of TARGET_LIST) {
+  await compile_target({ target });
+}
+
+type CompileTargetArgs = {
+  target: string;
+};
+async function compile_target(args: CompileTargetArgs) {
+  const outfile = path.join(DIST_DIR, "bin", `git-stack-${args.target}`);
+
+  const start = Date.now();
+
+  // bun build --compile --target=bun-darwin-x64 ./path/to/my/app.ts --outfile myapp
+  const bun_compile = await spawn.sync([
+    "bun",
+    "build",
+    "--compile",
+    `--target=${args.target}`,
+    INPUT_JS,
+    `--outfile=${outfile}`,
+  ]);
+
+  if (bun_compile.proc.exitCode) {
+    console.error(bun_compile.stderr);
+    process.exit(bun_compile.proc.exitCode);
+  }
+
+  const duration_ms = Date.now() - start;
+
+  console.debug(`✅ ${path.relative(REPO_ROOT, outfile)} (${duration_ms}ms)`);
+}

package/scripts/npm-prepublishOnly.ts

@@ -2,7 +2,7 @@
 // ensure we are publishing through the custom script
 
 if (!process.env.GS_RELEASE_NPM) {
-  console.error("Must publish using `npm run release:npm`");
+  console.error("Must publish using `pnpm run release:npm`");
   console.error();
   process.exit(10);
 }

package/scripts/release-brew.ts

@@ -5,26 +5,19 @@ import * as file from "~/core/file";
 import { spawn } from "~/core/spawn";
 
 // get paths relative to this script
-const SCRIPT_DIR = import.meta.dir;
-const PROJECT_DIR = path.join(SCRIPT_DIR, "..");
-const DIST_DIR = path.join(PROJECT_DIR, "dist");
-const STANDALONE_DIR = path.join(DIST_DIR, "standalone");
-const HOMEBREW_DIR = path.join(PROJECT_DIR, "homebrew");
-
-const package_json = await file.read_json(
-  path.join(PROJECT_DIR, "package.json")
-);
+const REPO_ROOT = (await spawn.sync("git rev-parse --show-toplevel")).stdout;
+const DIST_DIR = path.join(REPO_ROOT, "dist");
+const BIN_DIR = path.join(DIST_DIR, "bin");
+const HOMEBREW_DIR = path.join(REPO_ROOT, "homebrew");
+
+const package_json = await file.read_json(path.join(REPO_ROOT, "package.json"));
 
 const version = package_json.version;
 
 process.chdir(HOMEBREW_DIR);
 
 // before creating new formula, mv the previous into a versioned formula name
-const previous_formula_path = path.join(
-  HOMEBREW_DIR,
-  "Formula",
-  "git-stack.rb"
-);
+const previous_formula_path = path.join(HOMEBREW_DIR, "Formula", "git-stack.rb");
 
 // match either version format from core or tap formula
 //
@@ -42,36 +35,29 @@ if (!previous_version_match?.groups) {
 
 const previous_version = previous_version_match.groups.version;
 // convert `1.0.4` to `104`
-const not_dot_version = previous_version.replace(/\./g, "");
+const not_dot_version = previous_version.replace(/[^a-z0-9]/gi, "");
 const previous_class = `GitStackAT${not_dot_version}`;
-previous_formula = previous_formula.replace(
-  "class GitStack",
-  `class ${previous_class}`
-);
+previous_formula = previous_formula.replace("class GitStack", `class ${previous_class}`);
 
 await file.write_text(
   path.join(HOMEBREW_DIR, "Formula", `git-stack@${previous_version}.rb`),
-  previous_formula
+  previous_formula,
 );
 
-process.chdir(PROJECT_DIR);
+process.chdir(REPO_ROOT);
 
-// download github asset and calculate sha256
-// prettier-ignore
-await spawn.sync(["gh", "release", "download", version, "-p", `git-stack-cli-${version}.tgz`]);
-// prettier-ignore
 const tarball_asset = await create_asset(`git-stack-cli-${version}.tgz`, { version });
-await file.rm(tarball_asset.filepath);
 
-await spawn(`npm run build:standalone`);
+await spawn(`pnpm run compile`);
 
-process.chdir(STANDALONE_DIR);
+process.chdir(BIN_DIR);
 
-const linux_asset = await create_asset("git-stack-cli-linux", { version });
-const macos_asset = await create_asset("git-stack-cli-macos", { version });
-const win_asset = await create_asset("git-stack-cli-win.exe", { version });
+const linux_x64_asset = await create_asset("git-stack-bun-linux-x64.zip", { version });
+const macos_x64_asset = await create_asset("git-stack-bun-darwin-x64.zip", { version });
+const macos_arm64_asset = await create_asset("git-stack-bun-darwin-arm64.zip", { version });
+const win_x64_asset = await create_asset("git-stack-bun-windows-x64.exe.zip", { version });
 
-console.debug({ linux_asset, macos_asset, win_asset });
+console.debug({ linux_x64_asset, macos_x64_asset, macos_arm64_asset, win_x64_asset });
 
 const re_token = (name: string) => new RegExp(`{{ ${name} }}`, "g");
 
@@ -79,35 +65,27 @@ process.chdir(HOMEBREW_DIR);
 
 // homebrew tap formula (binaries)
 
-let tap = await file.read_text(
-  path.join("templates", "git-stack.tap.rb.template")
-);
+let tap = await file.read_text(path.join("templates", "git-stack.tap.rb.template"));
 
 tap = tap.replace(re_token("version"), version);
-tap = tap.replace(re_token("mac_bin"), macos_asset.filepath);
-tap = tap.replace(re_token("mac_sha256"), macos_asset.sha256);
-tap = tap.replace(re_token("linux_bin"), linux_asset.filepath);
-tap = tap.replace(re_token("linux_sha256"), linux_asset.sha256);
+tap = tap.replace(re_token("mac_x64_bin"), macos_x64_asset.filepath);
+tap = tap.replace(re_token("mac_x64_sha256"), macos_x64_asset.sha256);
+tap = tap.replace(re_token("mac_arm64_bin"), macos_arm64_asset.filepath);
+tap = tap.replace(re_token("mac_arm64_sha256"), macos_arm64_asset.sha256);
+tap = tap.replace(re_token("linux_x64_bin"), linux_x64_asset.filepath);
+tap = tap.replace(re_token("linux_x64_sha256"), linux_x64_asset.sha256);
 
 await file.write_text(path.join("Formula", "git-stack.rb"), tap);
 
 // homebrew/core formula (build from source)
 
-let core = await file.read_text(
-  path.join("templates", "git-stack.core.rb.template")
-);
+let core = await file.read_text(path.join("templates", "git-stack.core.rb.template"));
 
 core = core.replace(re_token("version"), version);
 core = core.replace(re_token("tarball_sha256"), tarball_asset.sha256);
 
 await file.write_text(path.join("Formula", "git-stack.core.rb"), core);
 
-// finally upload the assets to the github release
-process.chdir(STANDALONE_DIR);
-await spawn.sync(`gh release upload ${version} ${linux_asset.filepath}`);
-await spawn.sync(`gh release upload ${version} ${macos_asset.filepath}`);
-await spawn.sync(`gh release upload ${version} ${win_asset.filepath}`);
-
 // commit homebrew repo changes
 process.chdir(HOMEBREW_DIR);
 await spawn.sync(`git add .`);
@@ -115,7 +93,7 @@ await spawn.sync(`git commit -m ${version}`);
 await spawn.sync(`git push`);
 
 // commmit changes to main repo
-process.chdir(PROJECT_DIR);
+process.chdir(REPO_ROOT);
 // prettier-ignore
 await spawn.sync(["git", "commit", "-a", "-m", `homebrew-git-stack ${version}`]);
 await spawn.sync(`git push`);

package/scripts/release-github.ts

@@ -5,29 +5,41 @@ import * as file from "~/core/file";
 import { spawn } from "~/core/spawn";
 
 // get paths relative to this script
-const SCRIPT_DIR = import.meta.dir;
-const PROJECT_DIR = path.join(SCRIPT_DIR, "..");
+const REPO_ROOT = (await spawn.sync("git rev-parse --show-toplevel")).stdout;
+const DIST_DIR = path.join(REPO_ROOT, "dist");
+const BIN_DIR = path.join(DIST_DIR, "bin");
 
-const package_json = await file.read_json(
-  path.join(PROJECT_DIR, "package.json")
-);
+const package_json = await file.read_json(path.join(REPO_ROOT, "package.json"));
 
 const version = package_json.version;
 
 // generates local tarball e.g. git-stack-cli-1.2.0.tgz
-await spawn("npm pack");
+await spawn("pnpm pack");
 
-// prettier-ignore
-const tarball_asset = await create_asset(`git-stack-cli-${version}.tgz`, { version });
+// generate single file executables for all targets
+await spawn(`pnpm run compile`);
 
 await spawn.sync(`gh release create ${version} -t ${version} --generate-notes`);
 
+const tarball_asset = await create_asset(`git-stack-cli-${version}.tgz`, { version });
 await spawn.sync(`gh release upload ${version} ${tarball_asset.filepath}`);
 
-await file.rm(tarball_asset.filepath);
+process.chdir(BIN_DIR);
+
+await zip_upload("git-stack-bun-darwin-arm64");
+await zip_upload("git-stack-bun-darwin-x64");
+await zip_upload("git-stack-bun-linux-x64");
+await zip_upload("git-stack-bun-windows-x64.exe");
 
 console.debug();
 console.debug("✅", "published", version);
 console.debug();
 console.debug("https://github.com/magus/git-stack-cli/releases");
 console.debug();
+
+async function zip_upload(filepath: string) {
+  const zip_filepath = `${filepath}.zip`;
+  await spawn.sync(`zip -r ${zip_filepath} ${filepath}`);
+  const asset = await create_asset(zip_filepath, { version });
+  await spawn.sync(`gh release upload ${version} ${asset.filepath}`);
+}

package/scripts/release-npm.ts

@@ -7,15 +7,14 @@ import { spawn } from "~/core/spawn";
 process.env.NODE_ENV = "production";
 
 // get paths relative to this script
-const SCRIPT_DIR = import.meta.dir;
-const PROJECT_DIR = path.join(SCRIPT_DIR, "..");
-const DIST_DIR = path.join(PROJECT_DIR, "dist");
+const REPO_ROOT = (await spawn.sync("git rev-parse --show-toplevel")).stdout;
+const DIST_DIR = path.join(REPO_ROOT, "dist");
 
 // clear entire dist output directory
 await fs.rmdir(DIST_DIR, { recursive: true });
 await fs.mkdir(DIST_DIR, { recursive: true });
 
-process.chdir(PROJECT_DIR);
+process.chdir(REPO_ROOT);
 
 // require clean git status besides changes to package.json version
 const git_status = await spawn.sync("git status --porcelain");
@@ -24,9 +23,7 @@ if (!/^M\s+package.json/.test(git_status.stdout)) {
   process.exit(4);
 }
 
-const package_json = await file.read_json(
-  path.join(PROJECT_DIR, "package.json")
-);
+const package_json = await file.read_json(path.join(REPO_ROOT, "package.json"));
 
 const version = package_json.version;
 
@@ -40,11 +37,11 @@ if (git_tag.stdout) {
 }
 
 // install all dependencies even though we are NODE_ENV=production
-await spawn(`npm install --production=false`);
+await spawn(`pnpm install --frozen-lockfile --production=false`);
 
-await spawn(`npm run test:all`);
+await spawn(`pnpm run test:all`);
 
-await spawn(`npm run build`);
+await spawn(`pnpm run build`);
 
 // confirm all files specified exist
 for (const filepath of package_json.files) {
@@ -61,7 +58,7 @@ console.info("Publishing to NPM requires a one-time password");
 const otp = await input("Enter OTP: ");
 await spawn(["npm", "publish", `--otp=${otp}`]);
 
-process.chdir(PROJECT_DIR);
+process.chdir(REPO_ROOT);
 
 await spawn.sync(`git commit -a -m ${version}`);
 await spawn.sync(`git push`);

package/src/app/Store.tsx

@@ -33,6 +33,11 @@ type SyncGithubState = {
 // async function that returns exit code
 type AbortHandler = () => Promise<number>;
 
+type ExitArgs = {
+  quiet?: boolean;
+  clear?: boolean;
+};
+
 export type State = {
   // set immediately in `index.tsx` so no `null` scenario
   process_argv: Array<string>;
@@ -53,7 +58,7 @@ export type State = {
   sync_github: null | SyncGithubState;
   is_dirty_check_stash: boolean;
   abort_handler: null | AbortHandler;
-  is_exiting: boolean;
+  exit_mode: null | "normal" | "quiet";
 
   step:
     | "github-api-error"
@@ -74,7 +79,7 @@ export type State = {
   pr: { [branch: string]: PullRequest };
 
   actions: {
-    exit(code: number, clear?: boolean): void;
+    exit(code: number, args?: ExitArgs): void;
     clear(): void;
     unmount(): void;
     newline(): void;
@@ -124,7 +129,7 @@ const BaseStore = createStore<State>()(
     sync_github: null,
     is_dirty_check_stash: false,
     abort_handler: null,
-    is_exiting: false,
+    exit_mode: null,
 
     step: "loading",
 
@@ -134,9 +139,15 @@ const BaseStore = createStore<State>()(
     pr: {},
 
     actions: {
-      exit(code, clear = true) {
+      exit(code, args) {
         set((state) => {
-          state.is_exiting = true;
+          if (args?.quiet ?? code === 0) {
+            state.exit_mode = "quiet";
+          } else {
+            state.exit_mode = "normal";
+          }
+
+          let clear = args?.clear ?? true;
 
           const node = <Exit clear={clear} code={code} />;
           state.mutate.output(state, { node });

package/src/commands/Fixup.tsx

@@ -118,4 +118,6 @@ async function run() {
       actions.output(<Ink.Text color={colors.green}>✅ Changes restored from stash</Ink.Text>);
     }
   }
+
+  actions.exit(0);
 }

package/src/commands/Log.tsx

@@ -65,4 +65,6 @@ async function run(args: Args) {
   const result = await cli(command);
 
   actions.output(result.stdout);
+
+  actions.exit(0);
 }

package/src/components/ExitingGate.tsx

@@ -11,17 +11,27 @@ type Props = {
 };
 
 export function ExitingGate(props: Props) {
-  const is_exiting = Store.useState((state) => state.is_exiting);
+  const exit_mode = Store.useState((state) => state.exit_mode);
 
-  if (!is_exiting) {
+  if (!exit_mode) {
     return props.children;
   }
 
-  return (
-    <Ink.Box flexDirection="column">
-      <Ink.Text color={colors.red}>
-        <FormatText message="🚨 Exiting…" />
-      </Ink.Text>
-    </Ink.Box>
-  );
+  switch (exit_mode) {
+    case "quiet":
+      return null;
+
+    case "normal":
+      return (
+        <Ink.Box flexDirection="column">
+          <Ink.Text color={colors.red}>
+            <FormatText message="🚨 Exiting…" />
+          </Ink.Text>
+        </Ink.Box>
+      );
+
+    default:
+      exit_mode satisfies never;
+      return null;
+  }
 }

package/src/core/GitReviseTodo.ts

@@ -112,7 +112,9 @@ GitReviseTodo.execute = async function grt_execute(args: ExecuteArgs) {
   const tmp_git_sequence_editor_path = path.join(os.tmpdir(), "git-sequence-editor.sh");
 
   // replaced at build time with literal contents of `scripts/git-sequence-editor.sh`
-  const GIT_SEQUENCE_EDITOR_SCRIPT = `process.env.GIT_SEQUENCE_EDITOR_SCRIPT`;
+  const GIT_SEQUENCE_EDITOR_SCRIPT = process.env.GIT_SEQUENCE_EDITOR_SCRIPT;
+
+  invariant(GIT_SEQUENCE_EDITOR_SCRIPT, "GIT_SEQUENCE_EDITOR_SCRIPT must exist");
 
   // write script to temporary path
   await fs.writeFile(tmp_git_sequence_editor_path, GIT_SEQUENCE_EDITOR_SCRIPT);
@@ -131,10 +133,10 @@ GitReviseTodo.execute = async function grt_execute(args: ExecuteArgs) {
     `revise --edit -i ${args.rebase_merge_base}`,
   ];
 
-  // ignore here is important to prevent scrollback clear
-  // change to pipe to see output temporarily
+  // `ignore` hdies output which helps prevent scrollback clear
+  // `pipe` helps see failures when git revise fails
   // https://github.com/magus/git-stack-cli/commit/f9f10e3ac3cd9a35ee75d3e0851a48391967a23f
-  await cli(command, { stdio: ["ignore", "ignore", "ignore"] });
+  await cli(command, { stdio: ["pipe", "pipe", "pipe"] });
 
   // cleanup tmp_git_sequence_editor_path
   await safe_rm(tmp_git_sequence_editor_path);

package/src/index.tsx

@@ -15,6 +15,10 @@ import { pretty_json } from "~/core/pretty_json";
   try {
     const argv = await command();
 
+    // required to get bun working with ink
+    // https://github.com/oven-sh/bun/issues/6862#issuecomment-2429444852
+    process.stdin.resume();
+
     process.on("uncaughtException", (error) => {
       console.error("🚨 uncaughtException");
       console.error(error);