binary-collections 2.0.7 → 2.0.8

package/lib/del-yarn-caches.cjs

@@ -16,11 +16,56 @@ var init_cjs_shims = __esm({
 var require_utils = __commonJS({
   "src/utils.js"(exports2, module2) {
     init_cjs_shims();
-    var { fs, path } = require("sbg-utility");
+    var fs = require("fs");
+    var path = require("upath");
     var argv = require("minimist")(process.argv.slice(2));
+    var { exec } = require("child_process");
+    var { URL: URL2 } = require("url");
+    var { promisify } = require("util");
+    var execAsync = promisify(exec);
+    async function parseGitRemotes() {
+      try {
+        const { stdout } = await execAsync("git remote -v");
+        const lines = stdout.split("\n");
+        const remotes = {};
+        lines.forEach((line) => {
+          const [name, url] = line.split("	");
+          if (name && url) {
+            const [repoUrl] = url.split(" ");
+            try {
+              const parsedUrl = new URL2(repoUrl);
+              const pathParts = parsedUrl.pathname.split("/").filter(Boolean);
+              if (parsedUrl.hostname === "github.com" && pathParts.length === 2) {
+                let repoPath = pathParts.join("/");
+                if (repoPath.endsWith(".git")) {
+                  repoPath = repoPath.slice(0, -4);
+                }
+                remotes[name] = repoPath;
+              }
+            } catch (e) {
+              console.error("URL Parsing Error:", e.message);
+            }
+          }
+        });
+        return remotes;
+      } catch (error) {
+        console.error("Error:", error.message);
+        return {};
+      }
+    }
+    module2.exports.parseGitRemotes = parseGitRemotes;
+    function joinPathPreserveDriveLetter(...segments) {
+      let fullPath = require("path").join(...segments);
+      if (/^[a-z]:\\/.test(fullPath)) {
+        fullPath = fullPath.charAt(0).toUpperCase() + fullPath.slice(1);
+      }
+      return fullPath;
+    }
+    module2.exports.joinPathPreserveDriveLetter = joinPathPreserveDriveLetter;
     function getArgs() {
       return argv;
     }
+    module2.exports.getArgs = getArgs;
     function del(fullPath) {
       if (fs.statSync(fullPath).isDirectory()) {
         const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
@@ -36,6 +81,7 @@ var require_utils = __commonJS({
         }
       }
     }
+    module2.exports.del = del;
     function delStream2(globStream) {
       globStream.stream().on("data", (result) => {
         const fullPath = path.resolve(process.cwd(), result);
@@ -48,8 +94,46 @@ var require_utils = __commonJS({
         del(fullPath);
       });
     }
+    module2.exports.delStream = delStream2;
+    function getFileTreeString(hashArray) {
+      const tree = {};
+      const hashMap = {};
+      for (const entry of hashArray) {
+        const [filePath, hash] = entry.split(" ");
+        hashMap[filePath] = hash;
+        const parts = filePath.split("/");
+        let current = tree;
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          if (i === parts.length - 1) {
+            current[part] = null;
+          } else {
+            current[part] = current[part] || {};
+            current = current[part];
+          }
+        }
+      }
+      function printNode(node, prefix = "", parentPath = "") {
+        const keys = Object.keys(node).sort();
+        let lines = [];
+        keys.forEach((key, idx) => {
+          const isLast = idx === keys.length - 1;
+          const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+          const currentPath = parentPath ? parentPath + "/" + key : key;
+          if (node[key] === null) {
+            lines.push(prefix + branch + key + " [" + (hashMap[currentPath] || "") + "]");
+          } else {
+            lines.push(prefix + branch + key + "/");
+            lines = lines.concat(printNode(node[key], prefix + (isLast ? "    " : "\u2502   "), currentPath));
+          }
+        });
+        return lines;
+      }
+      return printNode(tree, "", "").join("\n");
+    }
+    module2.exports.getFileTreeString = getFileTreeString;
     var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-    module2.exports = { del, delStream: delStream2, getArgs, delay };
+    module2.exports.delay = delay;
   }
 });
 

package/lib/del-yarn-caches.mjs

@@ -1,13 +1,11 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-OKYLF2MU.mjs";
+} from "./chunk-APBWENF6.mjs";
 import {
+  __require,
   init_esm_shims
-} from "./chunk-VXZQNLPU.mjs";
-import {
-  __require
-} from "./chunk-FB6YIQYR.mjs";
+} from "./chunk-AASHBCRW.mjs";
 
 // src/del-yarn-caches.js
 init_esm_shims();

package/lib/find-node-modules-cli.cjs

@@ -49,7 +49,15 @@ var require_find_node_modules = __commonJS({
         });
       });
     }
+    if (typeof module2 !== "undefined" && require.main === module2) {
+      findNodeModules2(null, console.log).then((dirs) => {
+        console.log(`Found ${dirs.length} node_modules directories.`);
+      }).catch((err) => {
+        console.error("Error finding node_modules directories:", err);
+      });
+    }
     module2.exports = findNodeModules2;
+    module2.exports.default = findNodeModules2;
   }
 });
 

package/lib/find-node-modules-cli.mjs

@@ -2,11 +2,10 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_find_node_modules
-} from "./chunk-BSD5CIRU.mjs";
+} from "./chunk-YX5U7XDR.mjs";
 import {
   init_esm_shims
-} from "./chunk-VXZQNLPU.mjs";
-import "./chunk-FB6YIQYR.mjs";
+} from "./chunk-AASHBCRW.mjs";
 
 // src/find-node-modules-cli.js
 init_esm_shims();

package/lib/find-node-modules.cjs

@@ -31,4 +31,12 @@ function findNodeModules(dir = process.cwd(), callback = null) {
     });
   });
 }
+if (typeof module !== "undefined" && require.main === module) {
+  findNodeModules(null, console.log).then((dirs) => {
+    console.log(`Found ${dirs.length} node_modules directories.`);
+  }).catch((err) => {
+    console.error("Error finding node_modules directories:", err);
+  });
+}
 module.exports = findNodeModules;
+module.exports.default = findNodeModules;

package/lib/find-node-modules.d.mts

@@ -6,5 +6,8 @@
  * @returns {Promise<string[]>} - A promise that resolves to an array of full paths to "node_modules" directories.
  */
 declare function findNodeModules(dir?: string, callback?: Function): Promise<string[]>;
+declare namespace findNodeModules {
+    export { findNodeModules as default };
+}
 
 export { findNodeModules as default };

package/lib/find-node-modules.d.ts

@@ -7,3 +7,6 @@ export = findNodeModules;
  * @returns {Promise<string[]>} - A promise that resolves to an array of full paths to "node_modules" directories.
  */
 declare function findNodeModules(dir?: string, callback?: Function): Promise<string[]>;
+declare namespace findNodeModules {
+    export { findNodeModules as default };
+}

package/lib/find-node-modules.js

@@ -38,4 +38,16 @@ function findNodeModules(dir = process.cwd(), callback = null) {
         });
     });
 }
+// Support both CommonJS and ESM usage
+if (typeof module !== "undefined" && require.main === module) {
+    findNodeModules(null, console.log)
+        .then((dirs) => {
+        console.log(`Found ${dirs.length} node_modules directories.`);
+    })
+        .catch((err) => {
+        console.error("Error finding node_modules directories:", err);
+    });
+}
+// ESM export support
 module.exports = findNodeModules;
+module.exports.default = findNodeModules;

package/lib/find-node-modules.mjs

@@ -1,7 +1,6 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_find_node_modules
-} from "./chunk-BSD5CIRU.mjs";
-import "./chunk-VXZQNLPU.mjs";
-import "./chunk-FB6YIQYR.mjs";
+} from "./chunk-YX5U7XDR.mjs";
+import "./chunk-AASHBCRW.mjs";
 export default require_find_node_modules();

package/lib/git/gitattributes.cjs

@@ -0,0 +1,171 @@
+// src/git/gitattributes.js
+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
+};

package/lib/git/gitattributes.d.mts

@@ -0,0 +1,35 @@
+/**
+ * Parse existing .gitattributes file into structured rules
+ * @param {string} gitattributesPath - Path to .gitattributes file
+ * @returns {Array} Array of parsed rules
+ */
+declare function parseGitAttributes(gitattributesPath: string): any[];
+/**
+ * Check if two patterns conflict (same or overlapping file patterns)
+ * @param {string} pattern1 - First pattern
+ * @param {string} pattern2 - Second pattern
+ * @returns {boolean} True if patterns conflict
+ */
+declare function patternsConflict(pattern1: string, pattern2: string): boolean;
+/**
+ * Merge existing rules with desired rules, detecting conflicts
+ * @param {Array} existingRules - Parsed existing rules
+ * @param {Array} desiredRules - Desired rules to add
+ * @returns {Object} Result with mergedRules, conflicts, and changes
+ */
+declare function mergeGitAttributeRules(existingRules: any[], desiredRules: any[]): any;
+/**
+ * Format merged rules back into .gitattributes content
+ * @param {Array} rules - Merged rules array
+ * @returns {string} Formatted .gitattributes content
+ */
+declare function formatGitAttributes(rules: any[]): string;
+/**
+ * Update .gitattributes file with new rules, handling conflicts intelligently
+ * @param {string} gitattributesPath - Path to .gitattributes file
+ * @param {Array} desiredRules - Array of desired rules to add/merge
+ * @returns {Object} Result with success status, conflicts, and changes
+ */
+declare function updateGitAttributes(gitattributesPath: string, desiredRules: any[]): any;
+
+export { formatGitAttributes, mergeGitAttributeRules, parseGitAttributes, patternsConflict, updateGitAttributes };

package/lib/git/gitattributes.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Parse existing .gitattributes file into structured rules
+ * @param {string} gitattributesPath - Path to .gitattributes file
+ * @returns {Array} Array of parsed rules
+ */
+export function parseGitAttributes(gitattributesPath: string): any[];
+/**
+ * Check if two patterns conflict (same or overlapping file patterns)
+ * @param {string} pattern1 - First pattern
+ * @param {string} pattern2 - Second pattern
+ * @returns {boolean} True if patterns conflict
+ */
+export function patternsConflict(pattern1: string, pattern2: string): boolean;
+/**
+ * Merge existing rules with desired rules, detecting conflicts
+ * @param {Array} existingRules - Parsed existing rules
+ * @param {Array} desiredRules - Desired rules to add
+ * @returns {Object} Result with mergedRules, conflicts, and changes
+ */
+export function mergeGitAttributeRules(existingRules: any[], desiredRules: any[]): any;
+/**
+ * Format merged rules back into .gitattributes content
+ * @param {Array} rules - Merged rules array
+ * @returns {string} Formatted .gitattributes content
+ */
+export function formatGitAttributes(rules: any[]): string;
+/**
+ * Update .gitattributes file with new rules, handling conflicts intelligently
+ * @param {string} gitattributesPath - Path to .gitattributes file
+ * @param {Array} desiredRules - Array of desired rules to add/merge
+ * @returns {Object} Result with success status, conflicts, and changes
+ */
+export function updateGitAttributes(gitattributesPath: string, desiredRules: any[]): any;

package/lib/git/gitattributes.js

@@ -0,0 +1,223 @@
+const fs = require("fs");
+/**
+ * Parse existing .gitattributes file into structured rules
+ * @param {string} gitattributesPath - Path to .gitattributes file
+ * @returns {Array} Array of parsed rules
+ */
+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();
+        // Skip empty lines and comments
+        if (!trimmedLine || trimmedLine.startsWith("#")) {
+            rules.push({
+                type: trimmedLine.startsWith("#") ? "comment" : "empty",
+                content: line,
+                lineNumber: index + 1
+            });
+            return;
+        }
+        // Parse rule line
+        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 {
+            // Invalid line, keep as-is
+            rules.push({
+                type: "invalid",
+                content: line,
+                lineNumber: index + 1
+            });
+        }
+    });
+    return rules;
+}
+/**
+ * Check if two patterns conflict (same or overlapping file patterns)
+ * @param {string} pattern1 - First pattern
+ * @param {string} pattern2 - Second pattern
+ * @returns {boolean} True if patterns conflict
+ */
+function patternsConflict(pattern1, pattern2) {
+    // Exact match
+    if (pattern1 === pattern2) {
+        return true;
+    }
+    // Universal pattern conflicts with everything
+    if (pattern1 === "*" || pattern2 === "*") {
+        return pattern1 !== pattern2;
+    }
+    // Simple glob overlap detection
+    const normalize = (p) => p.replace(/\{[^}]+\}/g, "*").replace(/\*+/g, "*");
+    const norm1 = normalize(pattern1);
+    const norm2 = normalize(pattern2);
+    return norm1 === norm2;
+}
+/**
+ * Merge existing rules with desired rules, detecting conflicts
+ * @param {Array} existingRules - Parsed existing rules
+ * @param {Array} desiredRules - Desired rules to add
+ * @returns {Object} Result with mergedRules, conflicts, and changes
+ */
+function mergeGitAttributeRules(existingRules, desiredRules) {
+    let mergedRules;
+    if (existingRules.length === 0) {
+        // If no existing rules, just add all desired rules in order
+        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) => {
+        // Look for an exact pattern match in existing rules
+        const existingIdx = mergedRules.findIndex((r) => r.type === "rule" && r.pattern === desired.pattern);
+        if (existingIdx !== -1) {
+            const existing = mergedRules[existingIdx];
+            if (existing.attributes === desired.attributes) {
+                // Already present, do nothing
+                conflicts.push({
+                    pattern: desired.pattern,
+                    existing: existing.attributes,
+                    proposed: desired.attributes,
+                    action: "kept existing (identical)"
+                });
+            }
+            else if (desired.priority > (existing.priority || 0)) {
+                // Replace with higher priority rule
+                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 {
+                // Keep existing rule
+                conflicts.push({
+                    pattern: desired.pattern,
+                    existing: existing.attributes,
+                    proposed: desired.attributes,
+                    action: "kept existing (lower priority)"
+                });
+            }
+        }
+        else {
+            // No exact pattern match, add new rule
+            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 };
+}
+/**
+ * Format merged rules back into .gitattributes content
+ * @param {Array} rules - Merged rules array
+ * @returns {string} Formatted .gitattributes content
+ */
+function formatGitAttributes(rules) {
+    return (rules
+        .map((rule) => {
+        if (rule.type === "rule") {
+            return `${rule.pattern} ${rule.attributes}`;
+        }
+        return rule.content;
+    })
+        .join("\n") + "\n");
+}
+/**
+ * Update .gitattributes file with new rules, handling conflicts intelligently
+ * @param {string} gitattributesPath - Path to .gitattributes file
+ * @param {Array} desiredRules - Array of desired rules to add/merge
+ * @returns {Object} Result with success status, conflicts, and changes
+ */
+function updateGitAttributes(gitattributesPath, desiredRules) {
+    try {
+        // Parse existing .gitattributes
+        const existingRules = parseGitAttributes(gitattributesPath);
+        // Merge rules and detect conflicts
+        const { mergedRules, conflicts, changes } = mergeGitAttributeRules(existingRules, desiredRules);
+        // Write updated .gitattributes if changes were made
+        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
+};