binary-collections 2.0.9 → 2.0.11

package/lib/chunk-6S4NXESK.mjs

@@ -0,0 +1,26 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __esm,
+  __export,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/ps/isWin.js
+var isWin_exports = {};
+__export(isWin_exports, {
+  default: () => isWin_default
+});
+var isWin, isWin_default;
+var init_isWin = __esm({
+  "src/ps/isWin.js"() {
+    init_esm_shims();
+    isWin = process.platform === "win32";
+    isWin_default = isWin;
+  }
+});
+
+export {
+  isWin_default,
+  isWin_exports,
+  init_isWin
+};

package/lib/chunk-7XTEJHOE.mjs

@@ -0,0 +1,193 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils
+} from "./chunk-Z6JLYU2J.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/package-resolutions-updater.mjs
+init_esm_shims();
+var utils = __toESM(require_utils(), 1);
+import * as dotenv from "dotenv";
+import fs from "fs";
+import https from "https";
+import os from "os";
+import path from "path";
+var projectDir = process.cwd();
+var envPath = path.join(projectDir, ".env");
+var args = utils.getArgs();
+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();
+}
+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
+  - dotenv \u2013 to load GitHub token from .env
+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)];
+}
+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 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 match = url.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/raw\/([^/]+)\/(.+)$/);
+  if (!match) throw new Error("Invalid GitHub raw URL");
+  const [, owner, repo, _oldHash, path2] = match;
+  return `https://github.com/${owner}/${repo}/raw/${latestHash}/${path2}`;
+}
+function parseGitHubUrl(url) {
+  const ghRepoRoot = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/?$/;
+  const ghTreeOrBlob = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/(tree|blob)\/([^/]+(?:\/[^/]+)*)/;
+  const ghRaw = /^https:\/\/raw\.githubusercontent\.com\/([^/]+)\/([^/]+)\/([^/]+)(\/.+)?$/;
+  const ghDotComRaw = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/raw\/([^/]+)\/.+/;
+  let match;
+  if (match = url.match(ghRaw)) {
+    const [, owner, repo, branch] = match;
+    return { owner, repo, branch, url };
+  }
+  if (match = url.match(ghDotComRaw)) {
+    const [, owner, repo, branch] = match;
+    return { owner, repo, branch, url };
+  }
+  if (match = url.match(ghTreeOrBlob)) {
+    const [, owner, repo, , branchPath] = match;
+    return { owner, repo, branch: branchPath, url };
+  }
+  if (match = url.match(ghRepoRoot)) {
+    const [, owner, repo] = match;
+    return { owner, repo, url };
+  }
+  throw new Error(`Unsupported GitHub URL: ${url}`);
+}
+
+export {
+  fetchJson,
+  getLatestCommit,
+  getLatestCommitAcrossBranches,
+  replaceRawWithLatestHash,
+  parseGitHubUrl
+};

package/lib/{chunk-ZYAQRPUL.mjs → chunk-7YD7IPFF.mjs}

@@ -1,11 +1,11 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-EGSSKVDH.mjs";
+} from "./chunk-A3VUZEJK.mjs";
 import {
   __commonJS,
   init_esm_shims
-} from "./chunk-AASHBCRW.mjs";
+} from "./chunk-QQ4A6DLD.mjs";
 
 // src/git/permissions.cjs
 var require_permissions = __commonJS({

package/lib/{chunk-SH3L6HHV.mjs → chunk-A2JQXI5Z.mjs}

@@ -1,11 +1,11 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-EGSSKVDH.mjs";
+} from "./chunk-A3VUZEJK.mjs";
 import {
   __commonJS,
   init_esm_shims
-} from "./chunk-AASHBCRW.mjs";
+} from "./chunk-QQ4A6DLD.mjs";
 
 // src/git/pull-strategy.cjs
 var require_pull_strategy = __commonJS({

package/lib/{chunk-EGSSKVDH.mjs → chunk-A3VUZEJK.mjs}

@@ -3,7 +3,7 @@ import {
   __commonJS,
   __require,
   init_esm_shims
-} from "./chunk-AASHBCRW.mjs";
+} from "./chunk-QQ4A6DLD.mjs";
 
 // src/git/utils.cjs
 var require_utils = __commonJS({

package/lib/chunk-AJDD5DZM.mjs

@@ -0,0 +1,109 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils as require_utils2
+} from "./chunk-A3VUZEJK.mjs";
+import {
+  require_utils
+} from "./chunk-Z6JLYU2J.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/git/user-config.cjs
+var require_user_config = __commonJS({
+  "src/git/user-config.cjs"(exports, module) {
+    init_esm_shims();
+    var gch = __require("git-command-helper");
+    var { runGitCommand, runGitCommandOutput } = require_utils2();
+    var { getArgs } = require_utils();
+    __require("dotenv").config({ path: __require("path").join(process.cwd(), ".env"), quiet: true });
+    function configureGitUser(cliUser = null, cliEmail = null, options = {}) {
+      console.log("\n=== Configuring Git User ===");
+      let username, email;
+      if (cliUser && cliEmail) {
+        username = cliUser.trim();
+        email = cliEmail.trim();
+        console.log("[i] Using CLI-provided user configuration");
+      } else {
+        username = process.env.GITHUB_USER ? process.env.GITHUB_USER.trim() : void 0;
+        email = process.env.GITHUB_EMAIL ? process.env.GITHUB_EMAIL.trim() : void 0;
+        if (username || email) {
+          console.log("[i] Using environment variable user configuration");
+        }
+      }
+      if (!username && !email) {
+        console.log("[i] No Git user configuration needed (no CLI args or environment variables set)");
+        return;
+      }
+      if (username) {
+        const success = runGitCommand(["config", "user.name", username], `Set Git username to "${username}"`);
+        if (!success) {
+          console.log("[i] Failed to set Git username, but continuing...");
+        }
+      } else {
+        console.log("[i] No username provided, skipping username configuration");
+      }
+      if (email) {
+        const success = runGitCommand(["config", "user.email", email], `Set Git email to "${email}"`);
+        if (!success) {
+          console.log("[i] Failed to set Git email, but continuing...");
+        }
+      } else {
+        console.log("[i] No email provided, skipping email configuration");
+      }
+      if (username || email) {
+        console.log("[\u2713] Git user configuration completed");
+      }
+      if (username) {
+        const remoteUrl = runGitCommandOutput(["remote", "get-url", "origin"], "Fetching remote URL for verification");
+        if (remoteUrl) {
+          console.log(`[i] Remote URL: ${remoteUrl}`);
+          const parsedUrl = gch.parseGitHubUrl(remoteUrl);
+          if (parsedUrl && parsedUrl.owner && username && parsedUrl.owner.toLowerCase() !== username.toLowerCase()) {
+            console.warn(
+              `
+[!] The GitHub remote owner ("${parsedUrl.owner}") does not match the configured username ("${username}").`
+            );
+            console.warn(`[!] If this is not intentional, consider updating the remote URL to use your username.`);
+            console.warn(`[!] Example: git remote set-url origin https://github.com/${username}/<repo>.git
+`);
+            const args = getArgs();
+            const updateRemote = options.updateRemote || args["update-remote"] === true;
+            if (updateRemote) {
+              let newUrl = remoteUrl;
+              if (/^https:\/\//.test(remoteUrl)) {
+                newUrl = remoteUrl.replace(/https:\/\/(?:[^@]+@)?github.com/, `https://${username}@github.com`);
+              } else if (/^git@github.com:/.test(remoteUrl)) {
+                console.warn(
+                  `[!] For SSH remotes, set your SSH config or use HTTPS with username if you want to change authentication user.`
+                );
+                return;
+              }
+              if (newUrl !== remoteUrl) {
+                const updated = runGitCommand(["remote", "set-url", "origin", newUrl], `Set origin to ${newUrl}`);
+                if (updated) {
+                  console.log(`[\u2713] Remote URL updated to: ${newUrl}`);
+                } else {
+                  console.warn(`[!] Failed to update remote URL. Please update it manually if needed.`);
+                }
+              } else {
+                console.log(`[i] Remote URL does not use HTTPS or already contains the username.`);
+              }
+            } else {
+              console.log(`[i] Remote URL not changed. Use --update-remote to update automatically.`);
+            }
+          }
+        }
+      }
+    }
+    module.exports = {
+      configureGitUser
+    };
+  }
+});
+
+export {
+  require_user_config
+};

package/lib/chunk-BZWVHODJ.mjs

@@ -0,0 +1,62 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/submodule-remove.cjs
+var require_submodule_remove = __commonJS({
+  "src/submodule-remove.cjs"(exports, module) {
+    init_esm_shims();
+    var { spawnAsync } = __require("cross-spawn");
+    var path = __require("upath");
+    var fs = __require("fs-extra");
+    var dotenv = __require("dotenv");
+    var envPath = path.resolve(process.cwd(), ".env");
+    if (fs.existsSync(envPath)) {
+      dotenv.config({ path: envPath, override: true, quiet: true });
+    }
+    async function removeSubmodule(submodulePath) {
+      try {
+        await spawnAsync("git", ["submodule", "deinit", "-f", submodulePath], { stdio: "inherit" });
+      } catch (error) {
+        console.warn(`Warning: Could not deinitialize submodule "${submodulePath}". It may not exist.`);
+        console.warn(error.message);
+      }
+      try {
+        await spawnAsync("git", ["config", "--remove-section", `submodule.${submodulePath}`], { stdio: "inherit" });
+      } catch (error) {
+        console.warn(`Warning: Could not remove git config section for submodule "${submodulePath}". It may not exist.`);
+        console.warn(error.message);
+      }
+      const gitModulesPath = path.resolve(".git", "modules", submodulePath);
+      if (fs.existsSync(gitModulesPath)) {
+        fs.rmSync(gitModulesPath, { recursive: true, force: true });
+        console.log(`Removed .git/modules entry for submodule "${submodulePath}".`);
+      } else {
+        console.warn(`Warning: The path "${gitModulesPath}" does not exist. Skipping removal of .git/modules entry.`);
+      }
+      const gitmodulesPath = path.resolve(".gitmodules");
+      if (fs.existsSync(gitmodulesPath)) {
+        let gitmodulesContent = fs.readFileSync(gitmodulesPath, "utf-8");
+        const submoduleSectionRegex = new RegExp(
+          `\\[submodule "${submodulePath.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}"]([\\s\\S]*?)(?=\\[|$)`,
+          "g"
+        );
+        gitmodulesContent = gitmodulesContent.replace(submoduleSectionRegex, "").trim();
+        fs.writeFileSync(gitmodulesPath, gitmodulesContent);
+        console.log(`Removed submodule "${submodulePath}" from .gitmodules.`);
+      } else {
+        console.warn(`Warning: The .gitmodules file does not exist. Skipping removal of submodule "${submodulePath}".`);
+      }
+      fs.rmSync(path.resolve(submodulePath), { recursive: true, force: true });
+      console.log(`Submodule "${submodulePath}" has been removed.`);
+    }
+    module.exports = removeSubmodule;
+  }
+});
+
+export {
+  require_submodule_remove
+};

package/lib/chunk-FCDQGYBF.mjs

@@ -0,0 +1,136 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  runChatGpt
+} from "./chunk-N436BNBK.mjs";
+import {
+  require_binary_collections_config
+} from "./chunk-YYLIQQKF.mjs";
+import {
+  require_utils
+} from "./chunk-Z6JLYU2J.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/git-diff.js
+init_esm_shims();
+var import_binary_collections_config = __toESM(require_binary_collections_config(), 1);
+import { execSync } from "child_process";
+import fs from "fs-extra";
+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 DIFF_OUTPUT = (0, import_binary_collections_config.getTempPath)("git-diff.txt");
+var GPT_DIFF_OUTPUT = (0, import_binary_collections_config.getTempPath)("gpt-question.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);
+if (!fs.existsSync(CACHE_DIR)) {
+  fs.mkdirSync(CACHE_DIR, { recursive: true });
+}
+function showHelp() {
+  console.log("\u{1F4DD} Git Diff Helper");
+  console.log("\u{1F4C4} Usage:");
+  console.log("  \u{1F4C2} git-diff FILE             Show staged diff of specified file");
+  console.log("  \u{1F4C2} git-diff --staged-only    Show staged diff of all files");
+  console.log("  \u{1F4C2} git-diff -s | -S          Same as --staged-only");
+  console.log("  \u{1F4C2} git-diff --ai             Run ChatGPT automation for commit message");
+  console.log("  \u{1F4C2} 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(`\u{1F50D} [i] 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 [i] No changes found for the specified criteria`);
+      fs.writeFileSync(DIFF_OUTPUT, "# No changes found\n");
+      console.log(`\u2705 Empty diff saved to "${DIFF_OUTPUT_RELATIVE}"`);
+      return;
+    }
+    fs.writeFileSync(DIFF_OUTPUT, result);
+    fs.writeFileSync(
+      GPT_DIFF_OUTPUT,
+      `Hello, ChatGPT!
+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 "${GPT_DIFF_OUTPUT_RELATIVE}"`);
+  } catch (error) {
+    console.error(`\u274C ${errorMessage}`);
+    console.error(`\u{1F4DD} Command: ${command}`);
+    console.error(`\u26A0\uFE0F Error: ${error.message}`);
+    if (error.message.includes("not a git repository")) {
+      console.error("\u{1F6A7} Make sure you are in a git repository");
+    }
+    process.exit(1);
+  }
+}
+async function mainGitDiff() {
+  const args = (0, import_utils.getArgs)();
+  const positional = args._ || [];
+  if (args.help || args.h) {
+    showHelp();
+  }
+  if (args["staged-only"] || args.s || args.S) {
+    runGitDiff(
+      "git --no-pager diff --staged",
+      `Full staged diff saved to "${DIFF_OUTPUT_RELATIVE}"`,
+      "Failed to save staged diff"
+    );
+  } else {
+    const file = positional[0];
+    if (!file) {
+      runGitDiff(
+        "git --no-pager diff",
+        `Full staged diff saved to "${DIFF_OUTPUT_RELATIVE}"`,
+        "Failed to save all diff's"
+      );
+    } else {
+      runGitDiff(
+        `git --no-pager diff --cached -- "${file}"`,
+        `Staged diff of "${file}" saved to "${DIFF_OUTPUT_RELATIVE}"`,
+        `Failed to generate diff for "${file}"`
+      );
+    }
+  }
+  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} Tip: 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
+};