binary-collections 2.0.6 → 2.0.8

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
+};

package/lib/git/gitattributes.mjs

@@ -0,0 +1,6 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_gitattributes
+} from "../chunk-JGR2NW6D.mjs";
+import "../chunk-AASHBCRW.mjs";
+export default require_gitattributes();

package/lib/git/line-endings.cjs

@@ -0,0 +1,74 @@
+"use strict";
+const path = require("upath");
+const fs = require("fs");
+const { runGitCommand } = require("./utils.cjs");
+const { updateGitAttributes } = require("./gitattributes.js");
+/**
+ * Force LF line endings configuration
+ * - Sets core.autocrlf = false
+ * - Sets core.eol = lf
+ * - Creates/updates .gitattributes with proper line ending rules
+ */
+function forceLfLineEndings() {
+    console.log("\n=== Configuring LF Line Endings ===");
+    // Force LF line endings
+    runGitCommand(["config", "core.autocrlf", "false"], "Disable automatic CRLF conversion");
+    runGitCommand(["config", "core.eol", "lf"], "Set end-of-line to LF");
+    // Create or update .gitattributes
+    const gitattributesPath = path.join(process.cwd(), ".gitattributes");
+    // Always ensure the universal LF rule is present, even if file exists
+    if (fs.existsSync(gitattributesPath)) {
+        let content = fs.readFileSync(gitattributesPath, "utf8");
+        // Match * text=auto eol=lf with any whitespace (space or tab) between tokens
+        if (!/^\*\s+text=auto\s+eol=lf/m.test(content)) {
+            content = `* text=auto eol=lf\n` + content;
+            fs.writeFileSync(gitattributesPath, content);
+        }
+    }
+    // Define desired rules with priorities
+    const desiredRules = [
+        { pattern: "*", attributes: "text=auto eol=lf", priority: 1 },
+        {
+            pattern: "*.{cmd,bat,ps1,sh,cmd1,cmd2,bat1,bat2,vbs}",
+            attributes: "text eol=crlf",
+            priority: 2
+        },
+        {
+            pattern: "*.{png,jpg,jpeg,gif,ico,svg,bmp,webp,avif,tiff,tif,psd,ai,eps,raw}",
+            attributes: "binary",
+            priority: 3
+        },
+        {
+            pattern: "*.{zip,tar,gz,7z,rar,exe,dll,so,bin,jar,war,ear,apk,msi,deb,rpm,iso,img,dmg,pdf,mp3,mp4,mov,avi,mkv,flv,wmv,ogg,webm,wav,aac,m4a,otf,ttf,woff,woff2,eot}",
+            attributes: "binary",
+            priority: 3
+        }
+    ];
+    // Update .gitattributes using the dedicated module
+    const result = updateGitAttributes(gitattributesPath, desiredRules);
+    // Report results
+    if (result.error) {
+        console.log(`[✗] Error updating .gitattributes: ${result.error}`);
+        return;
+    }
+    // Report conflicts if any
+    if (result.conflicts.length > 0) {
+        console.log("\n[!] Detected conflicts in .gitattributes:");
+        result.conflicts.forEach((conflict) => {
+            console.log(`    ${conflict.pattern}: ${conflict.existing} -> ${conflict.proposed} (${conflict.action})`);
+        });
+    }
+    // Report changes
+    if (result.success) {
+        console.log(`[✓] ${result.message}:`);
+        result.changes.forEach((change) => {
+            console.log(`    ${change.action}: ${change.pattern} ${change.attributes}`);
+        });
+    }
+    else {
+        console.log(`[i] ${result.message}`);
+    }
+}
+module.exports = {
+    forceLfLineEndings
+};

package/lib/git/line-endings.d.cts

@@ -0,0 +1,7 @@
+/**
+ * Force LF line endings configuration
+ * - Sets core.autocrlf = false
+ * - Sets core.eol = lf
+ * - Creates/updates .gitattributes with proper line ending rules
+ */
+export function forceLfLineEndings(): void;

package/lib/git/line-endings.d.mts

@@ -0,0 +1,83 @@
+const path = require("upath");
+const fs = require("fs");
+const { runGitCommand } = require("./utils.cjs");
+const { updateGitAttributes } = require("./gitattributes.js");
+
+/**
+ * Force LF line endings configuration
+ * - Sets core.autocrlf = false
+ * - Sets core.eol = lf
+ * - Creates/updates .gitattributes with proper line ending rules
+ */
+function forceLfLineEndings() {
+  console.log("\n=== Configuring LF Line Endings ===");
+
+  // Force LF line endings
+  runGitCommand(["config", "core.autocrlf", "false"], "Disable automatic CRLF conversion");
+  runGitCommand(["config", "core.eol", "lf"], "Set end-of-line to LF");
+
+  // Create or update .gitattributes
+  const gitattributesPath = path.join(process.cwd(), ".gitattributes");
+
+  // Always ensure the universal LF rule is present, even if file exists
+  if (fs.existsSync(gitattributesPath)) {
+    let content = fs.readFileSync(gitattributesPath, "utf8");
+    // Match * text=auto eol=lf with any whitespace (space or tab) between tokens
+    if (!/^\*\s+text=auto\s+eol=lf/m.test(content)) {
+      content = `* text=auto eol=lf\n` + content;
+      fs.writeFileSync(gitattributesPath, content);
+    }
+  }
+
+  // Define desired rules with priorities
+  const desiredRules = [
+    { pattern: "*", attributes: "text=auto eol=lf", priority: 1 },
+    {
+      pattern: "*.{cmd,bat,ps1,sh,cmd1,cmd2,bat1,bat2,vbs}",
+      attributes: "text eol=crlf",
+      priority: 2
+    },
+    {
+      pattern: "*.{png,jpg,jpeg,gif,ico,svg,bmp,webp,avif,tiff,tif,psd,ai,eps,raw}",
+      attributes: "binary",
+      priority: 3
+    },
+    {
+      pattern:
+        "*.{zip,tar,gz,7z,rar,exe,dll,so,bin,jar,war,ear,apk,msi,deb,rpm,iso,img,dmg,pdf,mp3,mp4,mov,avi,mkv,flv,wmv,ogg,webm,wav,aac,m4a,otf,ttf,woff,woff2,eot}",
+      attributes: "binary",
+      priority: 3
+    }
+  ];
+
+  // Update .gitattributes using the dedicated module
+  const result = updateGitAttributes(gitattributesPath, desiredRules);
+
+  // Report results
+  if (result.error) {
+    console.log(`[✗] Error updating .gitattributes: ${result.error}`);
+    return;
+  }
+
+  // Report conflicts if any
+  if (result.conflicts.length > 0) {
+    console.log("\n[!] Detected conflicts in .gitattributes:");
+    result.conflicts.forEach((conflict) => {
+      console.log(`    ${conflict.pattern}: ${conflict.existing} -> ${conflict.proposed} (${conflict.action})`);
+    });
+  }
+
+  // Report changes
+  if (result.success) {
+    console.log(`[✓] ${result.message}:`);
+    result.changes.forEach((change) => {
+      console.log(`    ${change.action}: ${change.pattern} ${change.attributes}`);
+    });
+  } else {
+    console.log(`[i] ${result.message}`);
+  }
+}
+
+module.exports = {
+  forceLfLineEndings
+};