binary-collections 2.0.10 → 2.0.12

package/lib/chunk-NVEG3LEZ.mjs

@@ -0,0 +1,143 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/rm-node-modules.cjs
+var require_rm_node_modules = __commonJS({
+  "src/rm-node-modules.cjs"(exports, module) {
+    init_esm_shims();
+    var fs = __require("fs-extra");
+    var path = __require("upath");
+    var ansiColors = __require("ansi-colors");
+    var child_process = __require("child_process");
+    var os = __require("os");
+    function generateBashScript(options = {}) {
+      const { dryRun = true } = options;
+      return `
+#!/bin/bash
+
+set -u
+
+cwd="$(pwd)"
+max_jobs=4
+DRY_RUN=${dryRun ? "true" : "false"}
+
+cleanup_letter() {
+  local letter="$1"
+
+  if [ "$DRY_RUN" = "true" ]; then
+    echo "Would remove: node_modules/\${letter}*"
+    echo "Would remove: node_modules/@types/\${letter}*"
+    echo "Would remove: node_modules/@\${letter}*"
+  else
+    rm -rf "\${cwd}/node_modules/\${letter}"*
+    echo "Removed: node_modules/\${letter}*"
+
+    rm -rf "\${cwd}/node_modules/@types/\${letter}"*
+    echo "Removed: node_modules/@types/\${letter}*"
+
+    rm -rf "\${cwd}/node_modules/@\${letter}"*
+    echo "Removed: node_modules/@\${letter}*"
+  fi
+}
+
+export -f cleanup_letter
+export cwd
+export DRY_RUN
+
+if [ "$DRY_RUN" = "true" ]; then
+  echo "Dry-run mode (pass --force to actually delete)"
+fi
+
+echo "Cleaning \${cwd}/node_modules..."
+
+running=0
+
+for letter in {a..z}; do
+  cleanup_letter "$letter" &
+
+  ((running++))
+
+  # limit concurrent jobs
+  if (( running >= max_jobs )); then
+    wait -n
+    ((running--))
+  fi
+done
+
+wait
+
+# final full cleanup (ensure nothing left behind)
+if [ "$DRY_RUN" = "true" ]; then
+  echo "Would remove: node_modules (final cleanup)"
+else
+  rm -rf "\${cwd}/node_modules"
+  echo "Removed: node_modules (final cleanup)"
+fi
+
+if [ "$DRY_RUN" = "true" ]; then
+  echo "Done (dry-run). Run with --force to delete for real."
+else
+  echo "Done cleaning node_modules."
+fi
+`.trim();
+    }
+    async function cleanUp(rootDir, options = {}) {
+      const { dryRun = true } = options;
+      const nodeModulesDir = path.join(rootDir, "node_modules");
+      const script = generateBashScript({ dryRun });
+      const tmpDir = os.tmpdir();
+      const name = `rm-node-modules-${Date.now()}-${Math.random().toString(36).slice(2)}.sh`;
+      const scriptPath = path.join(tmpDir, name);
+      try {
+        fs.writeFileSync(scriptPath, script, { encoding: "utf8" });
+        try {
+          fs.chmodSync(scriptPath, 493);
+        } catch {
+        }
+        const result = child_process.spawnSync("bash", [scriptPath], {
+          cwd: rootDir,
+          env: process.env,
+          encoding: "utf8",
+          shell: false
+        });
+        if (result.stdout) process.stdout.write(result.stdout);
+        if (result.stderr) process.stderr.write(result.stderr);
+        if (result.error) {
+          try {
+            console.warn(
+              ansiColors.yellow(`bash execution failed: ${result.error.message}. Falling back to Node removal.`)
+            );
+            console.log(`Cleaning ${ansiColors.cyan(nodeModulesDir)}...`);
+            fs.rmSync(nodeModulesDir, { recursive: true, force: true });
+            console.log(`Removed: ${ansiColors.green("node_modules (final cleanup)")}`);
+            console.log("Done cleaning node_modules.");
+            return {
+              code: 0,
+              stdout: result.stdout || "",
+              stderr: (result.stderr || "") + `
+${result.error.stack || result.error.message}`
+            };
+          } catch (e) {
+            return { code: 1, stdout: result.stdout || "", stderr: (result.stderr || "") + `
+${e.stack || e.message}` };
+          }
+        }
+        return { code: result.status ?? 0, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+      } finally {
+        try {
+          if (fs.existsSync(scriptPath)) fs.unlinkSync(scriptPath);
+        } catch {
+        }
+      }
+    }
+    module.exports = { generateBashScript, cleanUp };
+  }
+});
+
+export {
+  require_rm_node_modules
+};

package/lib/chunk-OGXVGBRI.mjs

@@ -0,0 +1,29 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/file/copy.mjs
+init_esm_shims();
+import fs from "fs-extra";
+import path from "upath";
+async function copy(src, dest) {
+  if (!await fs.pathExists(src)) {
+    throw new Error(`Source file does not exist: ${src}`);
+  }
+  const srcStat = await fs.stat(src);
+  let finalDest = dest;
+  if (srcStat.isFile()) {
+    const destExists = await fs.pathExists(dest);
+    const destStat = destExists ? await fs.stat(dest) : null;
+    if (destStat && destStat.isDirectory()) {
+      finalDest = path.join(dest, path.basename(src));
+    }
+  }
+  await fs.ensureDir(path.dirname(finalDest));
+  await fs.copy(src, finalDest, { overwrite: true });
+}
+
+export {
+  copy
+};

package/lib/chunk-OXV52GD5.mjs

@@ -0,0 +1,62 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/node-cache-cleaner/npx.ts
+init_esm_shims();
+import fs from "fs-extra";
+import upath from "upath";
+import os from "os";
+import { spawn } from "cross-spawn";
+function getNpmCacheDir() {
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    const child = spawn("npm", ["config", "get", "cache"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: true
+    });
+    let output = "";
+    let error = "";
+    (_a = child.stdout) == null ? void 0 : _a.on("data", (data) => {
+      output += data.toString();
+    });
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (data) => {
+      error += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(output.trim());
+      } else {
+        reject(new Error(`Failed to get npm cache directory (code ${code}): ${error}`));
+      }
+    });
+  });
+}
+async function removeDir(target) {
+  try {
+    const exists = await fs.pathExists(target);
+    if (exists) {
+      console.log(`Removing: ${target}`);
+      await fs.remove(target);
+    } else {
+      console.log(`Not found: ${target}`);
+    }
+  } catch (err) {
+    console.error(`Failed to remove ${target}:`, err);
+  }
+}
+async function cleanNpxCache() {
+  const cacheDir = await getNpmCacheDir();
+  console.log("Detected npm cache:", cacheDir);
+  console.log("\nCleaning npm/npx cache...\n");
+  const npxCache = upath.join(cacheDir, "_npx");
+  const npmCache = upath.join(cacheDir, "_cacache");
+  const altNpxLinux = upath.join(os.homedir(), ".cache", "npx");
+  await Promise.all([removeDir(npxCache), removeDir(npmCache), removeDir(altNpxLinux)]);
+  console.log("\nDone \u2714\uFE0F");
+}
+
+export {
+  cleanNpxCache
+};

package/lib/{chunk-PDSXF5HY.mjs → chunk-PDN26I7O.mjs}

@@ -179,6 +179,7 @@ var require_gitattributes = __commonJS({
       formatGitAttributes,
       updateGitAttributes
     };
+    module.exports.default = module.exports;
   }
 });
 

package/lib/chunk-PXBMHE7O.mjs

@@ -0,0 +1,35 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/binary-collections/executeScript.cjs
+var require_executeScript = __commonJS({
+  "src/binary-collections/executeScript.cjs"(exports, module) {
+    init_esm_shims();
+    var { spawn } = __require("child_process");
+    function executeScript(scriptPath, args) {
+      console.log(`\u{1F527} Executing script: ${scriptPath} args: ${args.join(" ")}
+`);
+      const child = spawn("node", [scriptPath, ...args], {
+        stdio: "inherit",
+        shell: true
+      });
+      child.on("error", (error) => {
+        console.error(`\u274C Error executing script: ${error.message}`);
+        process.exit(1);
+      });
+      child.on("close", (code) => {
+        process.exit(code);
+      });
+    }
+    module.exports = executeScript;
+    module.exports.default = executeScript;
+  }
+});
+
+export {
+  require_executeScript
+};

package/lib/chunk-R5FJOR63.mjs

@@ -0,0 +1,47 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/node-cache-cleaner/npm.ts
+init_esm_shims();
+import { spawn } from "cross-spawn";
+function npmVersion() {
+  return new Promise((resolve, reject) => {
+    const process = spawn("npm", ["--version"], {
+      stdio: "pipe",
+      shell: true
+    });
+    let version = "";
+    process.stdout.on("data", (data) => {
+      version += data.toString();
+    });
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve(version.trim());
+      } else {
+        reject(new Error(`NPM version check failed with exit code ${code}`));
+      }
+    });
+  });
+}
+function cleanNpmCache() {
+  return new Promise((resolve, reject) => {
+    const process = spawn("npm", ["cache", "clean", "--force"], {
+      stdio: "inherit",
+      shell: true
+    });
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve(true);
+      } else {
+        reject(new Error(`NPM cache clean failed with exit code ${code}`));
+      }
+    });
+  });
+}
+
+export {
+  npmVersion,
+  cleanNpmCache
+};

package/lib/chunk-SPTECFE5.mjs

@@ -0,0 +1,180 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-G5UUEWUO.mjs";
+import {
+  runChatGpt
+} from "./chunk-GAGABICI.mjs";
+import {
+  require_utils
+} from "./chunk-5RTXZVCW.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/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{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 --unstaged FILE  Show unstaged diff of specified file");
+  console.log("  \u{1F4C2} git-diff --unstaged       Show unstaged diff of all files");
+  console.log("  \u{1F4C2} git-diff -u               Same as --unstaged");
+  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`);
+      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, 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 "${ansiColors.green(GPT_DIFF_OUTPUT_RELATIVE)}"`);
+    return true;
+  } 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);
+  }
+}
+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"
+      );
+    } 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(`\u{1F4A1} 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} 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-UXCFNAR6.mjs

@@ -0,0 +1,55 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/node-cache-cleaner/yarn.ts
+init_esm_shims();
+import { spawn } from "cross-spawn";
+function yarnVersion() {
+  return new Promise((resolve, reject) => {
+    const process = spawn("yarn", ["--version"], {
+      stdio: "pipe",
+      shell: true
+    });
+    let version = "";
+    process.stdout.on("data", (data) => {
+      version += data.toString();
+    });
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve(version.trim());
+      } else {
+        reject(new Error(`Yarn version check failed with exit code ${code}`));
+      }
+    });
+  });
+}
+async function cleanYarnCache() {
+  let version = "";
+  try {
+    version = await yarnVersion();
+  } catch {
+  }
+  const major = parseInt(version.split(".")[0], 10);
+  const isClassic = major === 1 || version === "";
+  const args = isClassic ? ["cache", "clean"] : ["cache", "clean", "--all"];
+  return new Promise((resolve, reject) => {
+    const process = spawn("yarn", args, {
+      stdio: "inherit",
+      shell: true
+    });
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve(true);
+      } else {
+        reject(new Error(`Yarn cache clean failed with exit code ${code}`));
+      }
+    });
+  });
+}
+
+export {
+  yarnVersion,
+  cleanYarnCache
+};

package/lib/chunk-V2IBPCEV.mjs

@@ -0,0 +1,39 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  isWindows
+} from "./chunk-XPJGCDOD.mjs";
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/cross-env/variable.ts
+init_esm_shims();
+var pathLikeEnvVarWhitelist = /* @__PURE__ */ new Set(["PATH", "NODE_PATH"]);
+function replaceListDelimiters(varValue, varName = "") {
+  const targetSeparator = isWindows() ? ";" : ":";
+  if (!pathLikeEnvVarWhitelist.has(varName)) {
+    return varValue;
+  }
+  return varValue.replace(/(\\*):/g, (match, backslashes) => {
+    if (backslashes.length % 2) {
+      return match.substring(1);
+    }
+    return backslashes + targetSeparator;
+  });
+}
+function resolveEnvVars(varValue) {
+  const envUnixRegex = /(\\*)(\$(\w+)|\${(\w+)})/g;
+  return varValue.replace(envUnixRegex, (_, escapeChars, varNameWithDollarSign, varName, altVarName) => {
+    if (escapeChars.length % 2 === 1) {
+      return varNameWithDollarSign;
+    }
+    return escapeChars.substring(0, escapeChars.length / 2) + (process.env[varName || altVarName] || "");
+  });
+}
+function varValueConvert(originalValue, originalName) {
+  return resolveEnvVars(replaceListDelimiters(originalValue, originalName));
+}
+
+export {
+  varValueConvert
+};

package/lib/chunk-XPJGCDOD.mjs

@@ -0,0 +1,14 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/utils/isWindows.js
+init_esm_shims();
+function isWindows() {
+  return process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE || "");
+}
+
+export {
+  isWindows
+};

package/lib/{chunk-AI4CVPJ7.mjs → chunk-ZDMWBSYF.mjs}

@@ -1,10 +1,10 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_gitattributes
+} from "./chunk-PDN26I7O.mjs";
 import {
   require_utils
 } from "./chunk-A3VUZEJK.mjs";
-import {
-  require_gitattributes
-} from "./chunk-PDSXF5HY.mjs";
 import {
   __commonJS,
   __require,
@@ -18,7 +18,7 @@ var require_line_endings = __commonJS({
     var path = __require("upath");
     var fs = __require("fs");
     var { runGitCommand } = require_utils();
-    var { updateGitAttributes } = require_gitattributes().default;
+    var { updateGitAttributes } = require_gitattributes();
     function forceLfLineEndings() {
       console.log("\n=== Configuring LF Line Endings ===");
       runGitCommand(["config", "core.autocrlf", "false"], "Disable automatic CRLF conversion");