binary-collections 2.0.13 → 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-TBWXE7ST.mjs → chunk-BO4TZS4Q.mjs}

@@ -2,6 +2,9 @@ import { createRequire } from 'module'; const require = createRequire(import.met
 import {
   require_fetchResponse
 } from "./chunk-KLKAIFKI.mjs";
+import {
+  require_config
+} from "./chunk-PAZH45HS.mjs";
 import {
   require_findEnvFiles
 } from "./chunk-H44UWUFY.mjs";
@@ -16,6 +19,7 @@ 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";
@@ -38,7 +42,6 @@ if (!fs.existsSync(envPath)) {
 if (fs.existsSync(envPath)) {
   dotenv.config({ path: envPath, quiet: true, override: true });
 }
-var ACCESS_TOKEN = process.env.ACCESS_TOKEN || process.env.GITHUB_TOKEN;
 if (args.help || args.h) {
   showHelp();
 }
@@ -103,7 +106,7 @@ async function fetchJson(url) {
       "User-Agent": selectedUserAgent,
       Accept: "application/vnd.github.v3+json",
       "X-GitHub-Api-Version": "2022-11-28",
-      ...ACCESS_TOKEN ? { Authorization: `token ${ACCESS_TOKEN}` } : {}
+      ...import_config.GITHUB_ACCESS_TOKEN ? { Authorization: `token ${import_config.GITHUB_ACCESS_TOKEN}` } : {}
     },
     responseType: "json"
   });

package/lib/chunk-CM3IC5YC.mjs

@@ -0,0 +1,226 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_fetchResponse
+} from "./chunk-KLKAIFKI.mjs";
+import {
+  require_config
+} from "./chunk-SARIXFHP.mjs";
+import {
+  require_utils
+} from "./chunk-6RK5UCTP.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/package-resolutions-updater.mjs
+init_esm_shims();
+var import_config = __toESM(require_config(), 1);
+var import_fetchResponse = __toESM(require_fetchResponse(), 1);
+var utils = __toESM(require_utils(), 1);
+import fs from "fs";
+import { parseGitHubUrl } from "git-command-helper";
+import os from "os";
+import path from "upath";
+var args = utils.getArgs();
+if (args.help || args.h) {
+  showHelp();
+}
+function showHelp() {
+  const helpText = `
+GitHub Package Resolutions Updater
+Usage:
+  node src/package-resolutions-updater.mjs [options]
+Options:
+  --help, -h           Show this help message
+Description:
+  Updates the commit hashes in package.json's 'resolutions' field for GitHub tarball URLs to point to the latest commit SHA of the corresponding repository and branch.
+Features:
+  - Parses GitHub URLs to extract repository owner, name, and branch.
+  - Fetches the latest commit SHA across all branches using GitHub's API.
+  - Replaces the old branch or commit in the URL with the latest SHA.
+  - Overwrites package.json with the updated URLs.
+Requirements:
+  - GitHub Personal Access Token (GITHUB_TOKEN) via .env
+  - ESM support (type: "module" in package.json)
+  - Node.js v18+ recommended
+Dependencies:
+  - ansi-colors \u2013 for styled terminal output
+Examples:
+  node src/package-resolutions-updater.mjs
+  node src/package-resolutions-updater.mjs --help
+
+`;
+  console.log(helpText);
+  process.exit(0);
+}
+var GITHUB_USER_AGENTS = [
+  "octokit-rest.js/19.0.7",
+  "GitHub CLI/2.40.0",
+  "Mozilla/5.0 (compatible; GitHubCopilot/1.0)",
+  "PostmanRuntime/7.32.3",
+  "binary-collections-resolver/1.0 (+https://github.com/dimaslanjaka/bin)"
+];
+var userAgentDir = path.join(os.tmpdir(), "nodejs");
+var userAgentFile = path.join(userAgentDir, "useragent.txt");
+var selectedUserAgent;
+try {
+  if (!fs.existsSync(userAgentDir)) fs.mkdirSync(userAgentDir, { recursive: true });
+  if (fs.existsSync(userAgentFile)) {
+    const fileAgent = fs.readFileSync(userAgentFile, "utf-8").trim();
+    if (GITHUB_USER_AGENTS.includes(fileAgent)) {
+      selectedUserAgent = fileAgent;
+    }
+  }
+  if (!selectedUserAgent) {
+    selectedUserAgent = GITHUB_USER_AGENTS[Math.floor(Math.random() * GITHUB_USER_AGENTS.length)];
+    fs.writeFileSync(userAgentFile, selectedUserAgent, "utf-8");
+  }
+} catch (_e) {
+  selectedUserAgent = GITHUB_USER_AGENTS[Math.floor(Math.random() * GITHUB_USER_AGENTS.length)];
+}
+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;
+  const url = `https://api.github.com/repos/${owner}/${repo}/commits/${branch}`;
+  const json = await fetchJson(url);
+  const sha = json.sha;
+  const dateStr = ((_b = (_a = json.commit) == null ? void 0 : _a.committer) == null ? void 0 : _b.date) || ((_d = (_c = json.commit) == null ? void 0 : _c.author) == null ? void 0 : _d.date);
+  if (!sha || !dateStr) {
+    console.log(json);
+    throw new Error(`Missing SHA or date for ${owner}/${repo}@${branch}`);
+  }
+  return {
+    owner,
+    repo,
+    branch,
+    sha,
+    date: new Date(dateStr).toISOString()
+  };
+}
+async function getLatestCommitAcrossBranches(owner, repo) {
+  const branches = await fetchJson(`https://api.github.com/repos/${owner}/${repo}/branches`);
+  const commits = await Promise.all(
+    branches.map(async ({ name, commit }) => {
+      var _a, _b, _c, _d;
+      const commitSha = commit == null ? void 0 : commit.sha;
+      if (!commitSha) {
+        console.warn(`No commit SHA for '${owner}/${repo}' branch: ${name}`);
+        return { branch: name, sha: "", date: /* @__PURE__ */ new Date(0) };
+      }
+      try {
+        const commitData = await fetchJson(`https://api.github.com/repos/${owner}/${repo}/commits/${commitSha}`);
+        const dateStr = ((_b = (_a = commitData.commit) == null ? void 0 : _a.committer) == null ? void 0 : _b.date) || ((_d = (_c = commitData.commit) == null ? void 0 : _c.author) == null ? void 0 : _d.date);
+        const date = dateStr ? new Date(dateStr) : /* @__PURE__ */ new Date(0);
+        return { branch: name, sha: commitData.sha, date };
+      } catch (e) {
+        console.warn(`Failed to fetch commit for ${name}: ${e.message}`);
+        return { branch: name, sha: commitSha, date: /* @__PURE__ */ new Date(0) };
+      }
+    })
+  );
+  const latest = commits.reduce((a, b) => a.date > b.date ? a : b, { date: /* @__PURE__ */ new Date(0) });
+  return {
+    owner,
+    repo,
+    branch: latest.branch,
+    sha: latest.sha,
+    date: latest.date.toISOString()
+  };
+}
+function replaceRawWithLatestHash(url, latestHash) {
+  const parsed = parseGitHubUrl(url);
+  if (!parsed || !parsed.owner || !parsed.repo || !parsed.branch) {
+    throw new Error("Invalid GitHub raw URL");
+  }
+  const branchPrefix = `${parsed.branch}/`;
+  const rawPrefix = parsed.host === "github.com" ? `raw/${branchPrefix}` : branchPrefix;
+  const refsPrefix = `refs/heads/${branchPrefix}`;
+  const path2 = parsed.path.startsWith(rawPrefix) ? parsed.path.slice(rawPrefix.length) : parsed.path.startsWith(refsPrefix) ? parsed.path.slice(refsPrefix.length) : parsed.path.startsWith(branchPrefix) ? parsed.path.slice(branchPrefix.length) : parsed.path;
+  if (parsed.host === "github.com") {
+    return `https://github.com/${parsed.owner}/${parsed.repo}/raw/${latestHash}/${path2}`;
+  }
+  if (parsed.host === "raw.githubusercontent.com") {
+    return `https://raw.githubusercontent.com/${parsed.owner}/${parsed.repo}/${latestHash}/${path2}`;
+  }
+  throw new Error("Invalid GitHub raw URL");
+}
+async function resolvePackageResolutionUpdates(resolutions, specialPackageOverrides = []) {
+  const updates = [];
+  for (const [currentPkgName, url] of Object.entries(resolutions || {})) {
+    let repo;
+    try {
+      repo = parseGitHubUrl(url);
+    } catch (error) {
+      updates.push({
+        skipped: true,
+        currentPkgName,
+        url,
+        error
+      });
+      continue;
+    }
+    try {
+      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);
+      const response = await (0, import_fetchResponse.default)(new_url);
+      if (response.status < 200 || response.status >= 300) {
+        updates.push({
+          failed: true,
+          currentPkgName,
+          url,
+          new_url,
+          repo,
+          latest,
+          error: new Error(`New URL not accessible (status ${response.status}).
+original: ${url}
+new: ${new_url}`)
+        });
+        continue;
+      }
+      updates.push({
+        currentPkgName,
+        url,
+        new_url,
+        repo,
+        latest
+      });
+    } catch (error) {
+      updates.push({
+        failed: true,
+        currentPkgName,
+        url,
+        repo,
+        error
+      });
+    }
+  }
+  return updates;
+}
+
+export {
+  parseGitHubUrl,
+  fetchJson,
+  getLatestCommit,
+  getLatestCommitAcrossBranches,
+  replaceRawWithLatestHash,
+  resolvePackageResolutionUpdates
+};

package/lib/{chunk-FLYSZFLW.mjs → chunk-D42YBRZW.mjs}

@@ -1,7 +1,7 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_package
-} from "./chunk-NQXUYO67.mjs";
+} from "./chunk-AJ3OIYYP.mjs";
 import {
   __commonJS,
   __dirname,