binary-collections 2.0.12 → 2.0.14

package/lib/chunk-BDCMTOZI.mjs

@@ -0,0 +1,246 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-SWUAEY4H.mjs";
+import {
+  runChatGpt
+} from "./chunk-GAGABICI.mjs";
+import {
+  require_utils
+} from "./chunk-6RK5UCTP.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/git/git-diff.js
+init_esm_shims();
+var import_config = __toESM(require_config(), 1);
+import ansiColors from "ansi-colors";
+import { execSync } from "child_process";
+import fs from "fs-extra";
+import { md5, writefile } from "sbg-utility";
+import path from "upath";
+import { fileURLToPath } from "url";
+var import_utils = __toESM(require_utils(), 1);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var args = (0, import_utils.getArgs)();
+var positional = args._ || [];
+var FILENAME = md5((positional[0] || "default") + JSON.stringify(args));
+var DIFF_OUTPUT = (0, import_config.getTempPath)(`git-diff/${FILENAME}.txt`);
+var GPT_DIFF_OUTPUT = (0, import_config.getTempPath)(`git-diff/gpt-${FILENAME}.txt`);
+var CACHE_DIR = path.dirname(DIFF_OUTPUT);
+var DIFF_OUTPUT_RELATIVE = path.relative(process.cwd(), DIFF_OUTPUT);
+var GPT_DIFF_OUTPUT_RELATIVE = path.relative(process.cwd(), GPT_DIFF_OUTPUT);
+fs.ensureDirSync(CACHE_DIR, { mode: 493 });
+function showHelp() {
+  console.log("\u{1F4CB} Git Diff Helper");
+  console.log("Usage:");
+  console.log("  git-diff FILE             Show staged diff of specified file");
+  console.log("  git-diff --staged-only    Show staged diff of all files");
+  console.log("  git-diff -s | -S          Same as --staged-only");
+  console.log("  git-diff --unstaged FILE  Show unstaged diff of specified file");
+  console.log("  git-diff --unstaged       Show unstaged diff of all files");
+  console.log("  git-diff -u               Same as --unstaged");
+  console.log("  git-diff --ai             Run ChatGPT automation for commit message");
+  console.log("  git-diff --help | -h      Show this help message");
+  console.log("");
+  console.log(`\u{1F4BE} Output is saved to: ${DIFF_OUTPUT_RELATIVE}`);
+  console.log(`\u{1F916} GPT prompt is saved to: ${GPT_DIFF_OUTPUT_RELATIVE}`);
+  process.exit(0);
+}
+function runGitDiff(command, successMessage, errorMessage) {
+  try {
+    console.log(`\u2139\uFE0F  Running command: ${command}`);
+    const result = execSync(command, {
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024 * 10
+      // 10MB buffer to handle large diffs
+    });
+    if (!result || result.trim() === "") {
+      console.log(`\u2139\uFE0F  No changes found for the specified criteria`);
+      writefile(DIFF_OUTPUT, "# No changes found\n");
+      console.log(`\u2705 Empty diff saved to "${DIFF_OUTPUT_RELATIVE}"`);
+      return false;
+    }
+    writefile(DIFF_OUTPUT, result);
+    writefile(
+      GPT_DIFF_OUTPUT,
+      `Hello!
+Can you create a conventional commit message by diff content below:
+
+\`\`\`${result}
+\`\`\`
+
+Give me result as codeblock with language "text" only.
+
+Thank you!`
+    );
+    console.log(`\u2705 ${successMessage}`);
+    console.log(`\u{1F4BE} GPT diff prompt saved to "${ansiColors.green(GPT_DIFF_OUTPUT_RELATIVE)}"`);
+    return true;
+  } catch (error) {
+    console.error(`\u274C ${errorMessage}`);
+    console.error(`\u274C Command: ${command}`);
+    console.error(`\u274C Error: ${error.message}`);
+    if (error.message.includes("not a git repository")) {
+      console.error("\u274C Make sure you are in a git repository");
+    }
+    process.exit(1);
+  }
+}
+function getUntrackedDiff() {
+  try {
+    const untrackedStr = execSync("git ls-files --others --exclude-standard", {
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024 * 10
+    }).trim();
+    if (!untrackedStr) return "";
+    const untrackedFiles = untrackedStr.split("\n").filter(function(f) {
+      return f;
+    });
+    if (untrackedFiles.length === 0) return "";
+    var result = "\n# Untracked files:\n";
+    for (var i = 0; i < untrackedFiles.length; i++) {
+      var file = untrackedFiles[i];
+      if (!fs.existsSync(file)) continue;
+      var stat = fs.statSync(file);
+      if (!stat.isFile()) continue;
+      var content;
+      try {
+        content = fs.readFileSync(file, "utf8");
+      } catch (_a) {
+        continue;
+      }
+      var lines = content.split("\n");
+      if (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+      }
+      result += "diff --git a/" + file + " b/" + file + "\n";
+      result += "new file mode 100644\n";
+      result += "index 0000000..0000000\n";
+      result += "--- /dev/null\n";
+      result += "+++ b/" + file + "\n";
+      result += "@@ -0,0 +1," + (lines.length || 0) + " @@\n";
+      for (var j = 0; j < lines.length; j++) {
+        result += "+" + lines[j] + "\n";
+      }
+    }
+    return result;
+  } catch (_b) {
+    return "";
+  }
+}
+function fileHasChanges(file, mode) {
+  const command = mode === "staged" ? `git diff --cached --quiet -- "${file}"` : `git diff --quiet -- "${file}"`;
+  try {
+    execSync(command, { stdio: "ignore" });
+    return false;
+  } catch (error) {
+    if (error.status === 1) {
+      return true;
+    }
+    throw error;
+  }
+}
+async function mainGitDiff() {
+  if (args.help || args.h) {
+    showHelp();
+  }
+  const useUnstaged = args.unstaged || args.u;
+  const fileFromFlag = typeof args.unstaged === "string" ? args.unstaged : typeof args.u === "string" ? args.u : null;
+  let hasDiff = false;
+  if (args["staged-only"] || args.s || args.S) {
+    hasDiff = runGitDiff(
+      "git --no-pager diff --staged",
+      `Full staged diff saved to "${ansiColors.green(DIFF_OUTPUT_RELATIVE)}"`,
+      "Failed to save staged diff"
+    );
+  } else {
+    const file = positional[0] || fileFromFlag;
+    if (!file) {
+      const fullDiffModeLabel = useUnstaged ? "unstaged" : "unstaged";
+      hasDiff = runGitDiff(
+        "git --no-pager diff",
+        `Full ${fullDiffModeLabel} diff saved to "${ansiColors.green(DIFF_OUTPUT_RELATIVE)}"`,
+        "Failed to save all diff's"
+      );
+      const untrackedDiff = getUntrackedDiff();
+      if (untrackedDiff) {
+        const UNTRACKED_DIFF_OUTPUT = (0, import_config.getTempPath)(`git-diff/untracked-${FILENAME}.txt`);
+        const UNTRACKED_GPT_DIFF_OUTPUT = (0, import_config.getTempPath)(`git-diff/gpt-untracked-${FILENAME}.txt`);
+        const UNTRACKED_DIFF_OUTPUT_RELATIVE = path.relative(process.cwd(), UNTRACKED_DIFF_OUTPUT);
+        writefile(UNTRACKED_DIFF_OUTPUT, untrackedDiff);
+        writefile(
+          UNTRACKED_GPT_DIFF_OUTPUT,
+          `Hello!
+Can you create a conventional commit message by diff content below:
+
+\`\`\`${untrackedDiff}
+\`\`\`
+
+Give me result as codeblock with language "text" only.
+
+Thank you!`
+        );
+        console.log(`\u2705 Untracked file diff saved to "${ansiColors.green(UNTRACKED_DIFF_OUTPUT_RELATIVE)}"`);
+        console.log(
+          `\u{1F4BE} AI diff prompt saved to "${ansiColors.green(path.relative(process.cwd(), UNTRACKED_GPT_DIFF_OUTPUT))}"`
+        );
+        hasDiff = true;
+      }
+    } else {
+      let fileDiffMode = useUnstaged ? "unstaged" : "staged";
+      if (!useUnstaged && !fileHasChanges(file, "staged") && fileHasChanges(file, "unstaged")) {
+        fileDiffMode = "unstaged";
+      }
+      hasDiff = runGitDiff(
+        fileDiffMode === "unstaged" ? `git --no-pager diff -- "${file}"` : `git --no-pager diff --cached -- "${file}"`,
+        `${fileDiffMode[0].toUpperCase() + fileDiffMode.slice(1)} diff of "${file}" saved to "${ansiColors.green(
+          DIFF_OUTPUT_RELATIVE
+        )}"`,
+        `Failed to generate ${fileDiffMode} diff for "${file}"`
+      );
+    }
+  }
+  if (hasDiff) {
+    const opencodePrompt = [
+      "",
+      "\u{1F916} OpenCode Prompt Helper",
+      "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      "",
+      "\u{1F4C4} App Prompt:",
+      `   Generate a conventional commit message from diff file: ${DIFF_OUTPUT}`,
+      "",
+      "\u{1F4BB} CLI Command:",
+      `   opencode run "Generate a conventional commit message from diff file ${DIFF_OUTPUT}"`,
+      ""
+    ];
+    const opencodePromptPath = (0, import_config.getTempPath)(`git-diff/opencode-${FILENAME}.txt`);
+    writefile(opencodePromptPath, opencodePrompt.join("\n"));
+    console.log(`\u2705 OpenCode prompt saved to "${ansiColors.green(path.relative(process.cwd(), opencodePromptPath))}"`);
+  }
+  if (args.ai) {
+    try {
+      await runChatGpt({ headless: true, questionFile: GPT_DIFF_OUTPUT });
+    } catch (error) {
+      console.error("\u274C Error running ChatGPT:", error.message);
+      console.error("\u{1F4A1} Try running with visible browser mode or check if Chrome is installed");
+    }
+  } else {
+    console.log("\u{1F4A1} Use --ai flag to generate commit message with ChatGPT");
+  }
+}
+var git_diff_default = runGitDiff;
+
+export {
+  DIFF_OUTPUT,
+  GPT_DIFF_OUTPUT,
+  CACHE_DIR,
+  DIFF_OUTPUT_RELATIVE,
+  GPT_DIFF_OUTPUT_RELATIVE,
+  runGitDiff,
+  mainGitDiff,
+  git_diff_default
+};

package/lib/chunk-BEUM4LH4.mjs

@@ -0,0 +1,184 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-SARIXFHP.mjs";
+import {
+  require_utils
+} from "./chunk-6RK5UCTP.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/github-workflows/clean-github-actions-caches.cjs
+var require_clean_github_actions_caches = __commonJS({
+  "src/github-workflows/clean-github-actions-caches.cjs"(exports, module) {
+    init_esm_shims();
+    var axios = __require("axios");
+    var { getArgs } = require_utils();
+    var { GITHUB_ACCESS_TOKEN: ACCESS_TOKEN } = require_config();
+    if (!ACCESS_TOKEN) {
+      throw new Error(
+        "Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables."
+      );
+    }
+    function printHelp() {
+      console.log(`
+GitHub Actions Cache Cleaner
+
+Description:
+  Removes outdated GitHub Actions caches for a repository, keeping only the newest
+  cache for each cache-key prefix. Authenticates via ACCESS_TOKEN or GITHUB_TOKEN
+  from your environment or .env file.
+
+Usage:
+  clean-github-actions-caches [options]
+
+Options:
+  -h, --help           Show this help message
+  -r, --repo <repo>    GitHub repository (owner/repo). If omitted, the tool will
+                       attempt to infer the repository from the current working
+                       directory's git remotes.
+    -p, --prefix-depth <n>
+                         Number of leading cache key segments to use as the
+                         grouping prefix when splitting on /[-_]/. Default: 3.
+
+Environment Variables:
+  ACCESS_TOKEN         GitHub access token (preferred)
+  GITHUB_TOKEN         GitHub access token (fallback)
+
+Behavior & Safety:
+  - Groups caches by a derived prefix from the cache key and keeps the most
+    recently created cache for each group.
+  - Deletes only caches older than the latest per prefix to reduce risk of
+    removing needed artifacts.
+
+Examples:
+  # Run against a specific repo (owner/repo)
+  clean-github-actions-caches --repo octocat/hello-world
+
+  # Run via npx without installing
+    npx --legacy-peer-deps -y binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches --repo owner/repo --prefix-depth 3
+
+  # Run via yarn dlx
+    yarn dlx binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches --prefix-depth 3
+
+Notes:
+  - Ensure ACCESS_TOKEN or GITHUB_TOKEN is set and has permissions to manage Actions caches.
+  - Intended for repository maintainers with appropriate permissions.
+`);
+    }
+    var argv = getArgs({
+      alias: {
+        h: "help",
+        p: "prefix-depth",
+        r: "repo"
+      },
+      string: ["prefix-depth", "repo"],
+      boolean: ["help"]
+    });
+    if (argv.help) {
+      printHelp();
+      process.exit(0);
+    }
+    function deleteGitHubActionsCache(GH_REPO, cacheId) {
+      return new Promise((resolve, reject) => {
+        const url = `https://api.github.com/repos/${GH_REPO}/actions/caches/${cacheId}`;
+        const token = ACCESS_TOKEN;
+        if (!token) {
+          return reject(new Error("Access token is not provided"));
+        }
+        axios.delete(url, {
+          headers: {
+            Authorization: `token ${token}`,
+            Accept: "application/vnd.github.v3+json"
+          }
+        }).then((response) => {
+          console.log(`Cache (${cacheId}) deleted successfully`, response.data);
+          resolve(response.data);
+        }).catch((error) => {
+          var _a;
+          console.error("Error deleting cache:", ((_a = error.response) == null ? void 0 : _a.data) || error.message || "Unknown error");
+          reject(error);
+        });
+      });
+    }
+    function normalizePrefixDepth(prefixDepth) {
+      const parsed = Number(prefixDepth);
+      if (!Number.isFinite(parsed) || parsed < 1) {
+        return 3;
+      }
+      return Math.floor(parsed);
+    }
+    function isChecksumSegment(segment) {
+      return /^[a-f0-9]{32,}$/i.test(segment);
+    }
+    function getMeaningfulCacheKeyParts(key) {
+      return String(key).split(/[-_]/).filter(Boolean).filter((segment) => !isChecksumSegment(segment));
+    }
+    function getCachePrefix(key, prefixDepth = 3) {
+      const normalizedDepth = normalizePrefixDepth(prefixDepth);
+      const parts = String(key).split(/[-_]/).filter(Boolean);
+      const meaningfulParts = getMeaningfulCacheKeyParts(key);
+      if (meaningfulParts.length !== parts.length) {
+        if (meaningfulParts.length < normalizedDepth) {
+          return `${meaningfulParts.join("-")}-`;
+        }
+        return meaningfulParts.join("-");
+      }
+      if (parts.length <= normalizedDepth) {
+        return parts.join("-");
+      }
+      return parts.slice(0, normalizedDepth).join("-");
+    }
+    function groupCachesByPrefix(caches, prefixDepth = 3) {
+      return caches.reduce(
+        /**
+         * @param {Record<string, Record<string, any>[]>} acc
+         * @param {Record<string, any>} item
+         * @returns {Record<string, Record<string, any>[]>}
+         */
+        (acc, item) => {
+          const prefix = getCachePrefix(item.key, prefixDepth);
+          if (!acc[prefix]) {
+            acc[prefix] = [];
+          }
+          acc[prefix].push(item);
+          return acc;
+        },
+        {}
+      );
+    }
+    function get_caches(GH_REPO, prefixDepth = 3) {
+      const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
+      return new Promise((resolve, reject) => {
+        axios.get(url, {
+          headers: {
+            Accept: "application/vnd.github.v3+json",
+            Authorization: `token ${ACCESS_TOKEN}`
+          }
+        }).then((response) => {
+          const data = response.data.actions_caches;
+          const grouped = groupCachesByPrefix(data, prefixDepth);
+          resolve(grouped);
+        }).catch((error) => {
+          reject(error);
+        });
+      });
+    }
+    module.exports = {
+      deleteGitHubActionsCache,
+      getCachePrefix,
+      getMeaningfulCacheKeyParts,
+      get_caches,
+      groupCachesByPrefix,
+      isChecksumSegment,
+      normalizePrefixDepth
+    };
+  }
+});
+
+export {
+  require_clean_github_actions_caches
+};

package/lib/{chunk-66KDU4TX.mjs → chunk-BO4TZS4Q.mjs}

@@ -1,10 +1,16 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_fetchResponse
+} from "./chunk-KLKAIFKI.mjs";
+import {
+  require_config
+} from "./chunk-PAZH45HS.mjs";
 import {
   require_findEnvFiles
 } from "./chunk-H44UWUFY.mjs";
 import {
   require_utils
-} from "./chunk-5RTXZVCW.mjs";
+} from "./chunk-6RK5UCTP.mjs";
 import {
   __toESM,
   init_esm_shims
@@ -13,14 +19,14 @@ import {
 // src/package-resolutions-updater.mjs
 init_esm_shims();
 var utils = __toESM(require_utils(), 1);
+var import_config = __toESM(require_config(), 1);
+var import_fetchResponse = __toESM(require_fetchResponse(), 1);
 var import_findEnvFiles = __toESM(require_findEnvFiles(), 1);
 import * as dotenv from "dotenv";
 import fs from "fs";
-import https from "https";
 import os from "os";
-import path from "path";
+import path from "upath";
 import { parseGitHubUrl } from "git-command-helper";
-import axios from "axios";
 var projectDir = process.cwd();
 var envPath = path.join(projectDir, ".env");
 var args = utils.getArgs();
@@ -36,7 +42,6 @@ if (!fs.existsSync(envPath)) {
 if (fs.existsSync(envPath)) {
   dotenv.config({ path: envPath, quiet: true, override: true });
 }
-var ACCESS_TOKEN = process.env.GITHUB_TOKEN || process.env.ACCESS_TOKEN;
 if (args.help || args.h) {
   showHelp();
 }
@@ -94,33 +99,23 @@ try {
 } catch (_e) {
   selectedUserAgent = GITHUB_USER_AGENTS[Math.floor(Math.random() * GITHUB_USER_AGENTS.length)];
 }
-function fetchJson(url) {
-  const headers = {
-    "User-Agent": selectedUserAgent,
-    Accept: "application/vnd.github.v3+json",
-    "X-GitHub-Api-Version": "2022-11-28",
-    ...ACCESS_TOKEN ? { Authorization: `token ${ACCESS_TOKEN}` } : {}
-  };
-  return new Promise((resolve, reject) => {
-    https.get(url, { headers }, (res) => {
-      let data = "";
-      res.on("data", (chunk) => data += chunk);
-      res.on("end", () => {
-        try {
-          const json = JSON.parse(data);
-          if (res.statusCode < 200 || res.statusCode >= 300) {
-            return reject(
-              new Error(`GitHub API Error ${res.statusCode}: ${json.message || "Unknown error"}
-URL: ${url}`)
-            );
-          }
-          resolve(json);
-        } catch {
-          reject(new Error(`Invalid JSON from: ${url}`));
-        }
-      });
-    }).on("error", reject);
+async function fetchJson(url) {
+  var _a;
+  const response = await (0, import_fetchResponse.default)(url, {
+    headers: {
+      "User-Agent": selectedUserAgent,
+      Accept: "application/vnd.github.v3+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      ...import_config.GITHUB_ACCESS_TOKEN ? { Authorization: `token ${import_config.GITHUB_ACCESS_TOKEN}` } : {}
+    },
+    responseType: "json"
   });
+  if (response.status < 200 || response.status >= 300) {
+    const message = ((_a = response.data) == null ? void 0 : _a.message) || "Unknown error";
+    throw new Error(`GitHub API Error ${response.status}: ${message}
+URL: ${url}`);
+  }
+  return response.data;
 }
 async function getLatestCommit(owner, repo, branch = "main") {
   var _a, _b, _c, _d;
@@ -206,34 +201,8 @@ async function resolvePackageResolutionUpdates(resolutions, specialPackageOverri
       const override = specialPackageOverrides.find((p) => p.pkg === currentPkgName);
       const latest = override ? await getLatestCommit(override.owner, override.repo, override.branch) : await getLatestCommitAcrossBranches(repo.owner, repo.repo);
       const new_url = replaceRawWithLatestHash(url, latest.sha);
-      await axios.head(new_url, {
-        headers: {
-          "User-Agent": selectedUserAgent,
-          Accept: "application/vnd.github.v3+json",
-          "X-GitHub-Api-Version": "2022-11-28",
-          ...ACCESS_TOKEN ? { Authorization: `token ${ACCESS_TOKEN}` } : {}
-        }
-      }).then((response) => {
-        if (response.status < 200 || response.status >= 300) {
-          updates.push({
-            failed: true,
-            currentPkgName,
-            url,
-            new_url,
-            repo,
-            latest,
-            error: new Error(`New URL is not accessible, status code: ${response.status}`)
-          });
-          return;
-        }
-        updates.push({
-          currentPkgName,
-          url,
-          new_url,
-          repo,
-          latest
-        });
-      }).catch((e) => {
+      const response = await (0, import_fetchResponse.default)(new_url);
+      if (response.status < 200 || response.status >= 300) {
         updates.push({
           failed: true,
           currentPkgName,
@@ -241,9 +210,18 @@ async function resolvePackageResolutionUpdates(resolutions, specialPackageOverri
           new_url,
           repo,
           latest,
-          error: new Error(`New URL is not accessible: ${e.message}`)
+          error: new Error(`New URL not accessible (status ${response.status}).
+original: ${url}
+new: ${new_url}`)
         });
-        return null;
+        continue;
+      }
+      updates.push({
+        currentPkgName,
+        url,
+        new_url,
+        repo,
+        latest
       });
     } catch (error) {
       updates.push({