git-stack-cli 1.0.2 → 1.0.4

package/README.md

@@ -96,5 +96,5 @@ npm run release:npm
 ### Homebrew + Github
 
 ```bash
-npm run release:github
+npm run release:brew
 ```

package/dist/cjs/index.cjs

@@ -26826,7 +26826,7 @@ function Url(props) {
 }
 
 function is_command_available(command) {
-    const PATH = process.env["PATH"];
+    const PATH = process.env.PATH;
     invariant(PATH, "PATH env must exist");
     const path_list = PATH.split(path.delimiter);
     for (const dir of path_list) {
@@ -28680,7 +28680,7 @@ function RebaseCheck(props) {
             patch({ status });
         }
         catch (err) {
-            actions.error("Unable to check for rebase.");
+            actions.error("Must be run from within a git repository.");
             if (err instanceof Error) {
                 if (actions.isDebug()) {
                     actions.error(err.message);
@@ -34080,7 +34080,7 @@ async function command() {
         .wrap(null)
         // disallow unknown options
         .strict()
-        .version("1.0.2" )
+        .version("1.0.4" )
         .showHidden("show-hidden", "Show hidden options via `git stack help --show-hidden`")
         .help("help", "Show usage via `git stack help`").argv);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-stack-cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "",
   "author": "magus",
   "license": "MIT",
@@ -13,22 +13,29 @@
     "git-stack": "dist/cjs/index.cjs"
   },
   "files": [
-    "dist/cjs"
+    "dist/cjs",
+    "scripts",
+    "src",
+    "package-lock.json",
+    "rollup.config.mjs",
+    "tsconfig.json"
   ],
   "scripts": {
     "dev": "npm run build -- --watch",
     "build": "rollup -c rollup.config.mjs",
-    "build:standalone": "bun run scripts/prepare-standalone.ts",
-    "release:github": "bun run scripts/publish-release.ts",
-    "release:npm": "npm publish",
+    "build:standalone": "bun run scripts/build-standalone.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",
     "lint:check": "eslint . --cache",
     "lint": "npm run lint:check -- --fix",
     "prettier:check": "prettier ./src --check --cache",
     "prettier": "npm run prettier:check -- --write",
-    "test": "bun test src",
+    "test": "bun test",
     "test:watch": "npm run test -- --watch",
-    "test:all": "npm run prettier:check && npm run lint:check && npm run build",
-    "prepublishOnly": "npm run test:all"
+    "test:types": "tsc",
+    "test:all": "npm run prettier:check && npm run lint:check && npm run test:types",
+    "prepublishOnly": "bun run scripts/npm-prepublishOnly.ts"
   },
   "dependencies": {
     "chalk": "^5.3.0",

package/rollup.config.mjs

@@ -0,0 +1,46 @@
+// npm i -D rollup @rollup/plugin-json @rollup/plugin-node-resolve @rollup/plugin-commonjs
+
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import * as url from "node:url";
+
+import alias from "@rollup/plugin-alias";
+import commonjs from "@rollup/plugin-commonjs";
+import json from "@rollup/plugin-json";
+import nodeResolve from "@rollup/plugin-node-resolve";
+import replace from "@rollup/plugin-replace";
+import typescript from "@rollup/plugin-typescript";
+
+const SCRIPT_DIR = path.dirname(url.fileURLToPath(import.meta.url));
+const PACKAGE_JSON_PATH = path.join(SCRIPT_DIR, "package.json");
+
+const package_json_str = await fs.readFile(PACKAGE_JSON_PATH, "utf-8");
+const package_json = JSON.parse(package_json_str);
+
+export default {
+  input: "src/index.tsx",
+
+  output: {
+    file: "dist/cjs/index.cjs",
+    format: "cjs",
+    inlineDynamicImports: true,
+  },
+
+  plugins: [
+    // force line break
+    typescript(),
+    alias({
+      entries: [{ find: /^~\//, replacement: "./src/" }],
+    }),
+    nodeResolve({ exportConditions: ["node"] }),
+    commonjs(),
+    json(),
+    replace({
+      preventAssignment: true,
+      values: {
+        "process.env.NODE_ENV": JSON.stringify("production"),
+        "process.env.CLI_VERSION": JSON.stringify(String(package_json.version)),
+      },
+    }),
+  ],
+};

package/scripts/.eslintrc.cjs

@@ -0,0 +1,61 @@
+const path = require("node:path");
+const import_eslint = require("../config/eslint/import.eslint.cjs");
+
+/** @type {import('eslint').Linter.Config} */
+module.exports = {
+  root: true,
+
+  ignorePatterns: [],
+
+  overrides: [
+    {
+      files: [".eslintrc.{js,cjs}"],
+
+      parserOptions: {
+        ecmaVersion: 13, // ES2022
+        sourceType: "script",
+      },
+
+      env: {
+        node: true,
+      },
+    },
+
+    {
+      files: ["**/*.{ts,tsx}"],
+
+      parser: "@typescript-eslint/parser",
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "script",
+        project: path.resolve(__dirname, "tsconfig.json"),
+      },
+
+      env: {
+        node: true,
+      },
+
+      settings: {
+        "import/resolver": {
+          typescript: true,
+          node: true,
+        },
+      },
+
+      extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+
+      plugins: ["@typescript-eslint", "import"],
+
+      rules: {
+        "@typescript-eslint/consistent-type-imports": [
+          "error",
+          { prefer: "type-imports", fixStyle: "separate-type-imports" },
+        ],
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-floating-promises": ["error"],
+
+        ...import_eslint.rules,
+      },
+    },
+  ],
+};

package/scripts/build-standalone.ts

@@ -0,0 +1,73 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+
+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 NODE_MODULES_BIN = path.join(PROJECT_DIR, "node_modules", ".bin");
+const DIST_DIR = path.join(PROJECT_DIR, "dist");
+const CJS_DIR = path.join(DIST_DIR, "cjs");
+const STANDALONE_DIR = path.join(DIST_DIR, "standalone");
+
+const ARG_LIST = process.argv.slice(2);
+const [maybe_target] = ARG_LIST;
+
+let TARGET = "node18-linux-x64,node18-macos-x64,node18-win-x64";
+if (maybe_target) {
+  TARGET = maybe_target;
+}
+
+console.debug(`Building for target [${TARGET}]`);
+
+// clear entire dist output directory
+await fs.rmdir(DIST_DIR, { recursive: true });
+await fs.mkdir(DIST_DIR, { recursive: true });
+
+const package_json = await file.read_json(
+  path.join(PROJECT_DIR, "package.json")
+);
+
+// prettier-ignore
+const { name, version, description, author, license, repository } = package_json;
+
+// include fields necessary for standalone executable build
+const standalone_package_json = {
+  name,
+  version,
+  description,
+  author,
+  license,
+  repository,
+  bin: {
+    "git-stack": "index.js",
+  },
+};
+
+await file.write_json(
+  path.join(STANDALONE_DIR, "package.json"),
+  standalone_package_json
+);
+
+process.chdir(PROJECT_DIR);
+
+process.env.NODE_ENV = "production";
+
+// run typescript build to generate module output
+await spawn("npm run build");
+
+await fs.cp(
+  path.join(CJS_DIR, "index.cjs"),
+  path.join(STANDALONE_DIR, "index.js")
+);
+
+process.chdir(STANDALONE_DIR);
+
+// run pkg to build standalone executable
+await spawn([
+  path.join(NODE_MODULES_BIN, "pkg"),
+  "package.json",
+  `--targets=${TARGET}`,
+]);

package/scripts/core/create_asset.ts

@@ -0,0 +1,21 @@
+import { spawn } from "~/core/spawn";
+
+// https://github.com/magus/git-stack-cli/releases/download/0.8.9/git-stack-cli-linux
+export async function create_asset(filepath: string, options: Options) {
+  const sha256_cmd = await spawn.sync(`shasum -a 256 ${filepath}`);
+  const match = sha256_cmd.stdout.match(/(?<sha256>[^\s]+)/i);
+
+  if (!match?.groups) {
+    throw new Error(`unable to get sha256 for ${filepath}`);
+  }
+
+  const sha256 = match.groups.sha256;
+
+  const url = `https://github.com/magus/git-stack-cli/releases/download/${options.version}/${filepath}`;
+
+  return { filepath, sha256, url };
+}
+
+type Options = {
+  version: string;
+};

package/scripts/core/file.ts

@@ -0,0 +1,36 @@
+import * as fs from "node:fs/promises";
+
+export async function read_json(filepath: string) {
+  const file = Bun.file(filepath);
+  const json = await file.json();
+  return json;
+}
+
+export async function write_json(filepath: string, data: any) {
+  const file = Bun.file(filepath);
+  await Bun.write(file, JSON.stringify(data, null, 2));
+}
+
+export async function read_text(filepath: string) {
+  const file = Bun.file(filepath);
+  const text = await file.text();
+  return text;
+}
+
+export async function write_text(filepath: string, text: string) {
+  const file = Bun.file(filepath);
+  await Bun.write(file, text);
+}
+
+export async function exists(filepath: string) {
+  try {
+    await fs.access(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function rm(filepath: string) {
+  await fs.rm(filepath);
+}

package/scripts/core/spawn.ts

@@ -0,0 +1,62 @@
+export async function spawn(unsafe_cmd: CommandLike) {
+  const cmd = get_cmd(unsafe_cmd);
+
+  console.debug();
+  console.debug("[spawn]", cmd.str);
+
+  const env = process.env;
+  const proc = await Bun.spawn(cmd.parts, {
+    env,
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+
+  await proc.exited;
+
+  if (proc.exitCode) {
+    console.error(`(${proc.exitCode})`, cmd.str);
+
+    if (!process.env.GS_NO_CHECK) {
+      process.exit(proc.exitCode);
+    }
+  }
+
+  console.debug("[end]", cmd.str);
+
+  return { proc };
+}
+
+spawn.sync = async function spawnSync(unsafe_cmd: CommandLike) {
+  const cmd = get_cmd(unsafe_cmd);
+
+  console.debug();
+  console.debug("[spawn.sync]", cmd.str);
+
+  const env = process.env;
+  const proc = await Bun.spawnSync(cmd.parts, { env });
+
+  const stdout = String(proc.stdout).trim();
+  const stderr = String(proc.stderr).trim();
+
+  console.debug("[end]", cmd.str);
+  console.debug({ stdout, stderr });
+
+  return { proc, stdout, stderr };
+};
+
+type CommandLike = string | Array<string>;
+
+function get_cmd(unsafe_cmd: CommandLike) {
+  let str;
+  let parts;
+
+  if (Array.isArray(unsafe_cmd)) {
+    parts = unsafe_cmd;
+    str = unsafe_cmd.join(" ");
+  } else {
+    parts = unsafe_cmd.split(" ");
+    str = unsafe_cmd;
+  }
+
+  return { parts, str };
+}

package/scripts/npm-prepublishOnly.ts

@@ -0,0 +1,8 @@
+// simply check for flag set by `scripts/release-npm`
+// 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();
+  process.exit(10);
+}

package/scripts/release-brew.ts

@@ -0,0 +1,69 @@
+import path from "node:path";
+
+import { create_asset } from "~/core/create_asset";
+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 version = package_json.version;
+
+process.chdir(STANDALONE_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 });
+
+console.debug({ linux_asset, macos_asset, win_asset });
+
+const re_token = (name: string) => new RegExp(`{{ ${name} }}`, "g");
+
+process.chdir(HOMEBREW_DIR);
+
+let formula = await file.read_text("git-stack.rb.template");
+
+formula = formula.replace(re_token("version"), version);
+formula = formula.replace(re_token("mac_bin"), macos_asset.filepath);
+formula = formula.replace(re_token("mac_sha256"), macos_asset.sha256);
+formula = formula.replace(re_token("linux_bin"), linux_asset.filepath);
+formula = formula.replace(re_token("linux_sha256"), linux_asset.sha256);
+
+await file.write_text("git-stack.rb", formula);
+
+await spawn.sync(`git commit -a -m ${version}`);
+await spawn.sync(`git push`);
+
+process.chdir(PROJECT_DIR);
+
+await spawn(`npm i`);
+
+await spawn.sync(`git commit -a -m ${version}`);
+await spawn.sync(`git push`);
+
+// -a: create tag on last commit
+// -m: message
+await spawn.sync(`git tag -a ${version} -m ${version}`);
+await spawn.sync(`git push origin ${version}`);
+
+await spawn.sync(`gh release create ${version} -t ${version} --generate-notes`);
+
+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}`);
+
+console.debug();
+console.debug("✅", "published", version);
+console.debug();
+console.debug("https://github.com/magus/homebrew-git-stack");
+console.debug();

package/scripts/release-github.ts

@@ -0,0 +1,34 @@
+import path from "node:path";
+
+import { create_asset } from "~/core/create_asset";
+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 package_json = await file.read_json(
+  path.join(PROJECT_DIR, "package.json")
+);
+
+const version = package_json.version;
+
+await spawn("npm pack");
+
+// prettier-ignore
+const tarball_asset = (
+  await create_asset(`git-stack-cli-${version}.tgz`, { version })
+);
+
+await spawn.sync(`gh release create ${version} -t ${version} --generate-notes`);
+
+await spawn.sync(`gh release upload ${version} ${tarball_asset.filepath}`);
+
+await file.rm(tarball_asset.filepath);
+
+console.debug();
+console.debug("✅", "published", version);
+console.debug();
+console.debug("https://github.com/magus/git-stack-cli/releases");
+console.debug();

package/scripts/release-npm.ts

@@ -0,0 +1,109 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+
+import * as file from "~/core/file";
+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");
+
+// clear entire dist output directory
+await fs.rmdir(DIST_DIR, { recursive: true });
+await fs.mkdir(DIST_DIR, { recursive: true });
+
+process.chdir(PROJECT_DIR);
+
+const package_json = await file.read_json(
+  path.join(PROJECT_DIR, "package.json")
+);
+
+const version = package_json.version;
+
+const git_tag = await spawn.sync(`git tag -l ${version}`);
+
+if (git_tag.stdout) {
+  console.error(`tag [${version}] already exists`);
+  if (!process.env.GS_NO_CHECK) {
+    process.exit(1);
+  }
+}
+
+// install all dependencies even though we are NODE_ENV=production
+await spawn(`npm install --production=false`);
+
+await spawn(`npm run test:all`);
+
+await spawn(`npm run build`);
+
+// confirm all files specified exist
+for (const filepath of package_json.files) {
+  if (!(await file.exists(filepath))) {
+    console.error("missing required file in package.json files", filepath);
+    if (!process.env.GS_NO_CHECK) {
+      process.exit(2);
+    }
+  }
+}
+
+process.env.GS_RELEASE_NPM = "true";
+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);
+
+await spawn.sync(`git commit -a -m ${version}`);
+await spawn.sync(`git push`);
+
+// -a: create tag on last commit
+// -m: message
+await spawn.sync(`git tag -a ${version} -m ${version}`);
+await spawn.sync(`git push origin ${version}`);
+
+console.debug();
+console.debug("✅", "published", version);
+console.debug();
+console.debug("https://www.npmjs.com/package/git-stack-cli");
+console.debug();
+
+// // https://github.com/magus/git-stack-cli/releases/download/0.8.9/git-stack-cli-linux
+// async function create_asset(name: string) {
+//   const sha256_cmd = await spawn.sync(`shasum -a 256 ${name}`);
+//   const match = sha256_cmd.stdout.match(/(?<sha256>[^\s]+)/i);
+
+//   if (!match?.groups) {
+//     throw new Error(`unable to get sha256 for ${name}`);
+//   }
+
+//   const sha256 = match.groups.sha256;
+
+//   const url = `https://github.com/magus/git-stack-cli/releases/download/${version}/${name}`;
+
+//   return { name, sha256, url };
+// }
+
+// function reFind(list: Array<string>, re: RegExp) {
+//   for (const str of list) {
+//     const match = str.match(re);
+
+//     if (match?.groups) {
+//       return match.groups.value;
+//     }
+//   }
+
+//   return null;
+// }
+
+async function input(prompt: string) {
+  process.stdout.write(prompt);
+  for await (const value of console) {
+    if (value) {
+      return value;
+    }
+    process.stdout.write(prompt);
+  }
+}

package/scripts/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["./*"]
+    },
+
+    "types": [
+      // add bun-types for resolving imports
+      //
+      //   import { test, expect } from "bun:test";
+      //
+      "bun-types"
+    ],
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    /* Linting */
+    "skipLibCheck": true,
+    "strict": true,
+    "noFallthroughCasesInSwitch": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}