@pubm/plugin-brew 0.4.0

package/dist/index.js

@@ -0,0 +1,313 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/brew-core.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+// src/formula.ts
+function toClassName(name) {
+  return name.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function findAsset(assets, platform) {
+  return assets.find((a) => a.platform === platform);
+}
+function generateFormula(opts) {
+  const className = toClassName(opts.name);
+  const darwinArm64 = findAsset(opts.assets, "darwin-arm64");
+  const darwinX64 = findAsset(opts.assets, "darwin-x64");
+  const linuxArm64 = findAsset(opts.assets, "linux-arm64");
+  const linuxX64 = findAsset(opts.assets, "linux-x64");
+  return `class ${className} < Formula
+  desc "${opts.desc}"
+  homepage "${opts.homepage}"
+  version "${opts.version}"
+  license "${opts.license}"
+
+  on_macos do
+    if Hardware::CPU.arm?
+      url "${darwinArm64?.url ?? "PLACEHOLDER"}"
+      sha256 "${darwinArm64?.sha256 ?? "PLACEHOLDER"}"
+    elsif Hardware::CPU.intel?
+      url "${darwinX64?.url ?? "PLACEHOLDER"}"
+      sha256 "${darwinX64?.sha256 ?? "PLACEHOLDER"}"
+    end
+  end
+
+  on_linux do
+    if Hardware::CPU.arm?
+      url "${linuxArm64?.url ?? "PLACEHOLDER"}"
+      sha256 "${linuxArm64?.sha256 ?? "PLACEHOLDER"}"
+    elsif Hardware::CPU.intel?
+      url "${linuxX64?.url ?? "PLACEHOLDER"}"
+      sha256 "${linuxX64?.sha256 ?? "PLACEHOLDER"}"
+    end
+  end
+
+  def install
+    bin.install "${opts.name}"
+  end
+
+  test do
+    system "#{bin}/${opts.name}", "--version"
+  end
+end
+`;
+}
+function updateFormula(content, version, assets) {
+  let updated = content.replace(/version\s+"[^"]+"/, `version "${version}"`);
+  for (const asset of assets) {
+    const platformPatterns = {
+      "darwin-arm64": { os: "on_macos", cpu: "arm" },
+      "darwin-x64": { os: "on_macos", cpu: "intel" },
+      "linux-arm64": { os: "on_linux", cpu: "arm" },
+      "linux-x64": { os: "on_linux", cpu: "intel" }
+    };
+    const pattern = platformPatterns[asset.platform];
+    if (!pattern)
+      continue;
+    const osBlockRegex = new RegExp(`(${pattern.os}\\s+do[\\s\\S]*?Hardware::CPU\\.${pattern.cpu}\\?\\s*\\n\\s*)url\\s+"[^"]+"(\\s*\\n\\s*)sha256\\s+"[^"]+"`, "m");
+    updated = updated.replace(osBlockRegex, `$1url "${asset.url}"$2sha256 "${asset.sha256}"`);
+  }
+  return updated;
+}
+function mapReleaseAssets(assets) {
+  const platformMap = {
+    "darwin-arm64": "darwin-arm64",
+    "darwin-x64": "darwin-x64",
+    "linux-arm64": "linux-arm64",
+    "linux-x64": "linux-x64"
+  };
+  const result = [];
+  for (const asset of assets) {
+    for (const [key, platform] of Object.entries(platformMap)) {
+      if (asset.name.includes(key)) {
+        result.push({ platform, url: asset.url, sha256: asset.sha256 });
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+// src/git-identity.ts
+import { execSync } from "node:child_process";
+function ensureGitIdentity(cwd) {
+  const opts = cwd ? { cwd, encoding: "utf-8" } : { encoding: "utf-8" };
+  try {
+    execSync("git config user.name", { ...opts, stdio: "pipe" });
+  } catch {
+    execSync('git config user.name "pubm[bot]"', opts);
+  }
+  try {
+    execSync("git config user.email", { ...opts, stdio: "pipe" });
+  } catch {
+    execSync('git config user.email "pubm[bot]@users.noreply.github.com"', opts);
+  }
+}
+
+// src/brew-core.ts
+function brewCore(options) {
+  return {
+    name: "@pubm/plugin-brew-core",
+    commands: [
+      {
+        name: "brew",
+        description: "Manage Homebrew formula",
+        subcommands: [
+          {
+            name: "init-core",
+            description: "Generate homebrew-core formula",
+            action: async () => {
+              const cwd = process.cwd();
+              const pkgPath = resolve(cwd, "package.json");
+              const pkg = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf-8")) : {};
+              const name = pkg.name?.replace(/^@[^/]+\//, "") ?? "my-tool";
+              const desc = pkg.description ?? "A CLI tool";
+              const homepage = pkg.homepage ?? `https://github.com/${name}`;
+              const license = pkg.license ?? "MIT";
+              const content = generateFormula({
+                name,
+                desc,
+                homepage,
+                license,
+                version: pkg.version ?? "0.0.0",
+                assets: []
+              });
+              const formulaPath = resolve(cwd, options.formula);
+              mkdirSync(dirname(formulaPath), { recursive: true });
+              writeFileSync(formulaPath, content);
+              console.log(`homebrew-core formula generated at ${options.formula}`);
+            }
+          }
+        ]
+      }
+    ],
+    hooks: {
+      afterRelease: async (_ctx, releaseCtx) => {
+        if (options.packageName && releaseCtx.packageName !== options.packageName) {
+          return;
+        }
+        const { execSync: execSync2 } = await import("node:child_process");
+        const cwd = process.cwd();
+        const pkgPath = resolve(cwd, "package.json");
+        const pkg = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf-8")) : {};
+        const name = pkg.name?.replace(/^@[^/]+\//, "") ?? "my-tool";
+        const formulaAssets = mapReleaseAssets(releaseCtx.assets);
+        try {
+          execSync2("gh repo fork homebrew/homebrew-core --clone=false", {
+            stdio: "pipe"
+          });
+        } catch {}
+        const username = execSync2("gh api user --jq .login", {
+          encoding: "utf-8"
+        }).trim();
+        const tmpDir = join(tmpdir(), `pubm-brew-core-${Date.now()}`);
+        execSync2(`git clone --depth 1 https://github.com/${username}/homebrew-core.git ${tmpDir}`, { stdio: "inherit" });
+        ensureGitIdentity(tmpDir);
+        const formulaPath = join(tmpDir, "Formula", `${name}.rb`);
+        let content;
+        if (existsSync(formulaPath)) {
+          const existing = readFileSync(formulaPath, "utf-8");
+          content = updateFormula(existing, releaseCtx.version, formulaAssets);
+        } else {
+          content = generateFormula({
+            name,
+            desc: pkg.description ?? "A CLI tool",
+            homepage: pkg.homepage ?? "",
+            license: pkg.license ?? "MIT",
+            version: releaseCtx.version,
+            assets: formulaAssets
+          });
+        }
+        mkdirSync(dirname(formulaPath), { recursive: true });
+        writeFileSync(formulaPath, content);
+        const branchName = `${name}-${releaseCtx.version}`;
+        execSync2([
+          `cd ${tmpDir}`,
+          `git checkout -b ${branchName}`,
+          `git add Formula/${name}.rb`,
+          `git commit -m "${name} ${releaseCtx.version}"`,
+          `git push origin ${branchName}`
+        ].join(" && "), { stdio: "inherit" });
+        execSync2([
+          `cd ${tmpDir}`,
+          `gh pr create --repo homebrew/homebrew-core --title "${name} ${releaseCtx.version}" --body "Update ${name} formula to version ${releaseCtx.version}"`
+        ].join(" && "), { stdio: "inherit" });
+        console.log(`PR created to homebrew/homebrew-core for ${name} ${releaseCtx.version}`);
+      }
+    }
+  };
+}
+// src/brew-tap.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
+function brewTap(options) {
+  return {
+    name: "@pubm/plugin-brew-tap",
+    commands: [
+      {
+        name: "brew",
+        description: "Manage Homebrew formula",
+        subcommands: [
+          {
+            name: "init",
+            description: "Generate Homebrew formula template",
+            action: async () => {
+              const cwd = process.cwd();
+              const pkgPath = resolve2(cwd, "package.json");
+              const pkg = existsSync2(pkgPath) ? JSON.parse(readFileSync2(pkgPath, "utf-8")) : {};
+              const name = pkg.name?.replace(/^@[^/]+\//, "") ?? "my-tool";
+              const desc = pkg.description ?? "A CLI tool";
+              const homepage = pkg.homepage ?? `https://github.com/${name}`;
+              const license = pkg.license ?? "MIT";
+              const content = generateFormula({
+                name,
+                desc,
+                homepage,
+                license,
+                version: pkg.version ?? "0.0.0",
+                assets: []
+              });
+              const formulaPath = resolve2(cwd, options.formula);
+              mkdirSync2(dirname2(formulaPath), { recursive: true });
+              writeFileSync2(formulaPath, content);
+              console.log(`Formula generated at ${options.formula}`);
+            }
+          }
+        ]
+      }
+    ],
+    hooks: {
+      afterRelease: async (_ctx, releaseCtx) => {
+        if (options.packageName && releaseCtx.packageName !== options.packageName) {
+          return;
+        }
+        const formulaAssets = mapReleaseAssets(releaseCtx.assets);
+        const formulaPath = resolve2(process.cwd(), options.formula);
+        let content;
+        if (existsSync2(formulaPath)) {
+          const existing = readFileSync2(formulaPath, "utf-8");
+          content = updateFormula(existing, releaseCtx.version, formulaAssets);
+        } else {
+          const cwd = process.cwd();
+          const pkgPath = resolve2(cwd, "package.json");
+          const pkg = existsSync2(pkgPath) ? JSON.parse(readFileSync2(pkgPath, "utf-8")) : {};
+          const name = pkg.name?.replace(/^@[^/]+\//, "") ?? "my-tool";
+          content = generateFormula({
+            name,
+            desc: pkg.description ?? "A CLI tool",
+            homepage: pkg.homepage ?? "",
+            license: pkg.license ?? "MIT",
+            version: releaseCtx.version,
+            assets: formulaAssets
+          });
+        }
+        mkdirSync2(dirname2(formulaPath), { recursive: true });
+        writeFileSync2(formulaPath, content);
+        console.log(`Formula updated at ${options.formula}`);
+        if (!options.repo) {
+          const { execSync: execSync2 } = await import("node:child_process");
+          ensureGitIdentity();
+          execSync2(`git add ${formulaPath}`, { stdio: "inherit" });
+          execSync2(`git commit -m "chore(brew): update formula to ${releaseCtx.version}"`, { stdio: "inherit" });
+          try {
+            execSync2("git push", { stdio: "inherit" });
+          } catch {
+            const branch = `pubm/brew-formula-v${releaseCtx.version}`;
+            execSync2(`git checkout -b ${branch}`, { stdio: "inherit" });
+            execSync2(`git push origin ${branch}`, { stdio: "inherit" });
+            execSync2(`gh pr create --title "chore(brew): update formula to ${releaseCtx.version}" --body "Automated formula update by pubm"`, { stdio: "inherit" });
+            console.log(`Created PR on branch ${branch}`);
+          }
+          return;
+        }
+        if (options.repo) {
+          const { tmpdir: tmpdir2 } = await import("node:os");
+          const { basename, join: join2 } = await import("node:path");
+          const { execSync: execSync2 } = await import("node:child_process");
+          const tmpDir = join2(tmpdir2(), `pubm-brew-tap-${Date.now()}`);
+          const formulaFile = basename(formulaPath);
+          execSync2(`git clone --depth 1 ${options.repo} ${tmpDir}`, {
+            stdio: "inherit"
+          });
+          ensureGitIdentity(tmpDir);
+          const targetDir = join2(tmpDir, "Formula");
+          mkdirSync2(targetDir, { recursive: true });
+          writeFileSync2(join2(targetDir, formulaFile), content);
+          execSync2([
+            `cd ${tmpDir}`,
+            `git add Formula/${formulaFile}`,
+            `git commit -m "Update ${formulaFile} to ${releaseCtx.version}"`,
+            "git push"
+          ].join(" && "), { stdio: "inherit" });
+        }
+      }
+    }
+  };
+}
+export {
+  brewTap,
+  brewCore
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@pubm/plugin-brew",
+  "version": "0.4.0",
+  "type": "module",
+  "description": "pubm plugin for Homebrew formula publishing workflows",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node --format esm && bunx tsc --project tsconfig.build.json",
+    "check": "biome check",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest --run --passWithNoTests",
+    "coverage": "vitest --run --coverage"
+  },
+  "license": "Apache-2.0",
+  "peerDependencies": {
+    "@pubm/core": ">=0.3.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/syi0808/pubm.git",
+    "directory": "packages/plugins/plugin-brew"
+  }
+}