binary-collections 2.0.10 → 2.0.11

package/lib/chunk-PDN26I7O.mjs

@@ -0,0 +1,188 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/git/gitattributes.cjs
+var require_gitattributes = __commonJS({
+  "src/git/gitattributes.cjs"(exports, module) {
+    init_esm_shims();
+    var fs = __require("fs");
+    function parseGitAttributes(gitattributesPath) {
+      const rules = [];
+      if (!fs.existsSync(gitattributesPath)) {
+        return rules;
+      }
+      const content = fs.readFileSync(gitattributesPath, "utf8");
+      const lines = content.split("\n");
+      lines.forEach((line, index) => {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith("#")) {
+          rules.push({
+            type: trimmedLine.startsWith("#") ? "comment" : "empty",
+            content: line,
+            lineNumber: index + 1
+          });
+          return;
+        }
+        const parts = trimmedLine.split(/\s+/);
+        if (parts.length >= 2) {
+          const pattern = parts[0];
+          const attributes = parts.slice(1).join(" ");
+          rules.push({
+            type: "rule",
+            pattern,
+            attributes,
+            content: line,
+            lineNumber: index + 1
+          });
+        } else {
+          rules.push({
+            type: "invalid",
+            content: line,
+            lineNumber: index + 1
+          });
+        }
+      });
+      return rules;
+    }
+    function patternsConflict(pattern1, pattern2) {
+      if (pattern1 === pattern2) {
+        return true;
+      }
+      if (pattern1 === "*" || pattern2 === "*") {
+        return pattern1 !== pattern2;
+      }
+      const normalize = (p) => p.replace(/\{[^}]+\}/g, "*").replace(/\*+/g, "*");
+      const norm1 = normalize(pattern1);
+      const norm2 = normalize(pattern2);
+      return norm1 === norm2;
+    }
+    function mergeGitAttributeRules(existingRules, desiredRules) {
+      let mergedRules;
+      if (existingRules.length === 0) {
+        mergedRules = desiredRules.map((desired, idx) => ({
+          type: "rule",
+          pattern: desired.pattern,
+          attributes: desired.attributes,
+          content: `${desired.pattern} ${desired.attributes}`,
+          lineNumber: idx + 1,
+          added: true
+        }));
+        return {
+          mergedRules,
+          conflicts: [],
+          changes: desiredRules.map((rule) => ({ action: "added", pattern: rule.pattern, attributes: rule.attributes }))
+        };
+      } else {
+        mergedRules = [...existingRules];
+      }
+      const conflicts = [];
+      const changes = [];
+      desiredRules.forEach((desired) => {
+        const existingIdx = mergedRules.findIndex((r) => r.type === "rule" && r.pattern === desired.pattern);
+        if (existingIdx !== -1) {
+          const existing = mergedRules[existingIdx];
+          if (existing.attributes === desired.attributes) {
+            conflicts.push({
+              pattern: desired.pattern,
+              existing: existing.attributes,
+              proposed: desired.attributes,
+              action: "kept existing (identical)"
+            });
+          } else if (desired.priority > (existing.priority || 0)) {
+            mergedRules[existingIdx] = {
+              type: "rule",
+              pattern: desired.pattern,
+              attributes: desired.attributes,
+              content: `${desired.pattern} ${desired.attributes}`,
+              lineNumber: existing.lineNumber,
+              replaced: true
+            };
+            conflicts.push({
+              pattern: desired.pattern,
+              existing: existing.attributes,
+              proposed: desired.attributes,
+              action: "replaced (higher priority)"
+            });
+            changes.push({
+              action: "replaced",
+              pattern: desired.pattern,
+              attributes: desired.attributes,
+              oldAttributes: existing.attributes
+            });
+          } else {
+            conflicts.push({
+              pattern: desired.pattern,
+              existing: existing.attributes,
+              proposed: desired.attributes,
+              action: "kept existing (lower priority)"
+            });
+          }
+        } else {
+          mergedRules.push({
+            type: "rule",
+            pattern: desired.pattern,
+            attributes: desired.attributes,
+            content: `${desired.pattern} ${desired.attributes}`,
+            lineNumber: mergedRules.length + 1,
+            added: true
+          });
+          changes.push({
+            action: "added",
+            pattern: desired.pattern,
+            attributes: desired.attributes
+          });
+        }
+      });
+      return { mergedRules, conflicts, changes };
+    }
+    function formatGitAttributes(rules) {
+      return rules.map((rule) => {
+        if (rule.type === "rule") {
+          return `${rule.pattern} ${rule.attributes}`;
+        }
+        return rule.content;
+      }).join("\n") + "\n";
+    }
+    function updateGitAttributes(gitattributesPath, desiredRules) {
+      try {
+        const existingRules = parseGitAttributes(gitattributesPath);
+        const { mergedRules, conflicts, changes } = mergeGitAttributeRules(existingRules, desiredRules);
+        let success = false;
+        if (changes.length > 0) {
+          const newContent = formatGitAttributes(mergedRules);
+          fs.writeFileSync(gitattributesPath, newContent);
+          success = true;
+        }
+        return {
+          success,
+          conflicts,
+          changes,
+          message: success ? `Updated .gitattributes with ${changes.length} changes` : "No changes needed - all rules already present"
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message,
+          conflicts: [],
+          changes: []
+        };
+      }
+    }
+    module.exports = {
+      parseGitAttributes,
+      patternsConflict,
+      mergeGitAttributeRules,
+      formatGitAttributes,
+      updateGitAttributes
+    };
+    module.exports.default = module.exports;
+  }
+});
+
+export {
+  require_gitattributes
+};

package/lib/{chunk-E6FDDAOO.mjs → chunk-RWLXRTYP.mjs}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-A3VUZEJK.mjs";
 import {
   require_utils
-} from "./chunk-V3N3JEUF.mjs";
+} from "./chunk-Z6JLYU2J.mjs";
 import {
   __commonJS,
   __require,

package/lib/{chunk-BDCHCWHD.mjs → chunk-TOIVAQF7.mjs}

@@ -1,13 +1,13 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   runChatGpt
-} from "./chunk-GJTGHXRA.mjs";
+} from "./chunk-N436BNBK.mjs";
 import {
   require_binary_collections_config
 } from "./chunk-66PAU5PS.mjs";
 import {
   require_utils
-} from "./chunk-V3N3JEUF.mjs";
+} from "./chunk-Z6JLYU2J.mjs";
 import {
   __toESM,
   init_esm_shims
@@ -17,8 +17,8 @@ import {
 init_esm_shims();
 var import_binary_collections_config = __toESM(require_binary_collections_config(), 1);
 import { execSync } from "child_process";
-import fs from "fs";
-import path from "path";
+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);

package/lib/chunk-V5SKYJUB.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-NCXAP7AA.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
+};

package/lib/{chunk-HMRMTYZM.mjs → chunk-WSRETQCA.mjs}

@@ -13,9 +13,14 @@ var require_submodule_remove = __commonJS({
     var path = __require("upath");
     var fs = __require("fs-extra");
     var dotenv = __require("dotenv");
-    dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+    dotenv.config({ path: path.resolve(process.cwd(), ".env"), override: true, quiet: true });
     async function removeSubmodule(submodulePath) {
-      await spawnAsync("git", ["submodule", "deinit", "-f", submodulePath], { stdio: "inherit" });
+      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) {
@@ -25,9 +30,23 @@ var require_submodule_remove = __commonJS({
       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.`);
     }

package/lib/chunk-XA3SNBPA.mjs

@@ -0,0 +1,184 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  findEnvFiles
+} from "./chunk-ID2WBTE2.mjs";
+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";
+import { parseGitHubUrl } from "git-command-helper";
+var projectDir = process.cwd();
+var envPath = path.join(projectDir, ".env");
+var args = utils.getArgs();
+if (!fs.existsSync(envPath)) {
+  const envFiles = findEnvFiles(projectDir, (file) => {
+    const content = fs.readFileSync(file, "utf-8");
+    return /GITHUB_TOKEN|ACCESS_TOKEN/.test(content);
+  });
+  if (envFiles.length > 0) {
+    envPath = envFiles[0];
+  }
+}
+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}`;
+}
+
+export {
+  parseGitHubUrl,
+  fetchJson,
+  getLatestCommit,
+  getLatestCommitAcrossBranches,
+  replaceRawWithLatestHash
+};

package/lib/chunk-YYLIQQKF.mjs

@@ -0,0 +1,31 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/binary-collections-config.cjs
+var require_binary_collections_config = __commonJS({
+  "src/binary-collections-config.cjs"(exports, module) {
+    init_esm_shims();
+    var path = __require("path");
+    __require("dotenv").config({ path: path.join(process.cwd(), ".env"), quiet: true, override: true });
+    function getTempDir() {
+      return process.env.TEMP_DIR || path.join(process.cwd(), "tmp");
+    }
+    function getTempPath(...segments) {
+      return path.join(getTempDir(), ...segments);
+    }
+    var TEMP_BASE_DIR = getTempDir();
+    module.exports = {
+      getTempDir,
+      getTempPath,
+      TEMP_BASE_DIR
+    };
+  }
+});
+
+export {
+  require_binary_collections_config
+};