binary-collections 2.0.7 → 2.0.8

package/lib/git/user-config.d.mts

@@ -0,0 +1,105 @@
+const gch = require("git-command-helper");
+const { runGitCommand, runGitCommandOutput } = require("./utils.cjs");
+const { getArgs } = require("../utils.js");
+
+/**
+ * Configure Git user from CLI arguments or environment variables
+ * @param {string|null} cliUser - Username from CLI arguments
+ * @param {string|null} cliEmail - Email from CLI arguments
+ * @param {object} [options] - Options object
+ * @param {boolean} [options.updateRemote] - If true, update remote URL without prompt
+ */
+function configureGitUser(cliUser = null, cliEmail = null, options = {}) {
+  console.log("\n=== Configuring Git User ===");
+
+  // Determine user and email with CLI args taking precedence
+  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() : undefined;
+    email = process.env.GITHUB_EMAIL ? process.env.GITHUB_EMAIL.trim() : undefined;
+    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("[✓] Git user configuration completed");
+  }
+
+  if (username) {
+    // Ask user to modify the origin remote URL if it doesn't match the 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(
+          `\n[!] 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\n`);
+        // Check for --update-remote CLI argument or options.updateRemote
+        const args = getArgs();
+        const updateRemote = options.updateRemote || args["update-remote"] === true;
+        if (updateRemote) {
+          // Only update the username in the URL, not the repo path
+          let newUrl = remoteUrl;
+          // Handle https:// and git@ URLs
+          if (/^https:\/\//.test(remoteUrl)) {
+            newUrl = remoteUrl.replace(/https:\/\/(?:[^@]+@)?github.com/, `https://${username}@github.com`);
+          } else if (/^git@github.com:/.test(remoteUrl)) {
+            // For git@github.com:user/repo.git, do not change path, just warn user to use HTTPS with username if needed
+            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(`[✓] 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
+};

package/lib/git/user-config.d.ts

@@ -0,0 +1,105 @@
+const gch = require("git-command-helper");
+const { runGitCommand, runGitCommandOutput } = require("./utils.cjs");
+const { getArgs } = require("../utils.js");
+
+/**
+ * Configure Git user from CLI arguments or environment variables
+ * @param {string|null} cliUser - Username from CLI arguments
+ * @param {string|null} cliEmail - Email from CLI arguments
+ * @param {object} [options] - Options object
+ * @param {boolean} [options.updateRemote] - If true, update remote URL without prompt
+ */
+function configureGitUser(cliUser = null, cliEmail = null, options = {}) {
+  console.log("\n=== Configuring Git User ===");
+
+  // Determine user and email with CLI args taking precedence
+  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() : undefined;
+    email = process.env.GITHUB_EMAIL ? process.env.GITHUB_EMAIL.trim() : undefined;
+    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("[✓] Git user configuration completed");
+  }
+
+  if (username) {
+    // Ask user to modify the origin remote URL if it doesn't match the 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(
+          `\n[!] 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\n`);
+        // Check for --update-remote CLI argument or options.updateRemote
+        const args = getArgs();
+        const updateRemote = options.updateRemote || args["update-remote"] === true;
+        if (updateRemote) {
+          // Only update the username in the URL, not the repo path
+          let newUrl = remoteUrl;
+          // Handle https:// and git@ URLs
+          if (/^https:\/\//.test(remoteUrl)) {
+            newUrl = remoteUrl.replace(/https:\/\/(?:[^@]+@)?github.com/, `https://${username}@github.com`);
+          } else if (/^git@github.com:/.test(remoteUrl)) {
+            // For git@github.com:user/repo.git, do not change path, just warn user to use HTTPS with username if needed
+            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(`[✓] 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
+};

package/lib/git/user-config.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_user_config
+} from "../chunk-ONIBBBQ3.mjs";
+import "../chunk-EGSSKVDH.mjs";
+import "../chunk-APBWENF6.mjs";
+import "../chunk-AASHBCRW.mjs";
+export default require_user_config();

package/lib/git/utils.cjs

@@ -0,0 +1,70 @@
+"use strict";
+const { execSync, spawnSync } = require("child_process");
+/**
+ * Execute a git command with proper error handling and logging
+ * @param {string[]} args - Git command arguments
+ * @param {string} description - Description of the operation for logging
+ * @returns {boolean} - True if successful, false otherwise
+ */
+function runGitCommand(args, description) {
+    try {
+        console.log(`[i] ${description}`);
+        const result = spawnSync("git", args, { encoding: "utf-8" });
+        if (result.status !== 0) {
+            console.error(`[✗] Failed: ${description}`);
+            console.error(`Error: ${result.stderr || result.stdout}`);
+            return false;
+        }
+        console.log(`[✓] ${description}`);
+        return true;
+    }
+    catch (error) {
+        console.error(`[✗] Failed: ${description}`);
+        console.error(`Error: ${error.message}`);
+        return false;
+    }
+}
+/**
+ * Check if the given cwd (or current directory) is a git repository
+ * @param {string} [cwd] - Directory to check (defaults to current directory at call time)
+ * @returns {boolean} - True if in a git repository, false otherwise
+ */
+function isGitRepository(cwd) {
+    const dir = typeof cwd === "string" ? cwd : process.cwd();
+    try {
+        execSync("git rev-parse --git-dir", { stdio: "pipe", cwd: dir });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Execute a git command and return stdout (or null on error)
+ * @param {string[]} args - Git command arguments
+ * @param {string} description - Description of the operation for logging
+ * @returns {string|null} - stdout string if successful, null otherwise
+ */
+function runGitCommandOutput(args, description) {
+    try {
+        console.log(`[i] ${description}`);
+        const result = spawnSync("git", args, { encoding: "utf-8" });
+        if (result.status !== 0) {
+            console.error(`[✗] Failed: ${description}`);
+            console.error(`Error: ${result.stderr || result.stdout}`);
+            return null;
+        }
+        console.log(`[✓] ${description}`);
+        return result.stdout.trim();
+    }
+    catch (error) {
+        console.error(`[✗] Failed: ${description}`);
+        console.error(`Error: ${error.message}`);
+        return null;
+    }
+}
+module.exports = {
+    runGitCommand,
+    runGitCommandOutput,
+    isGitRepository
+};

package/lib/git/utils.d.cts

@@ -0,0 +1,20 @@
+/**
+ * Execute a git command with proper error handling and logging
+ * @param {string[]} args - Git command arguments
+ * @param {string} description - Description of the operation for logging
+ * @returns {boolean} - True if successful, false otherwise
+ */
+export function runGitCommand(args: string[], description: string): boolean;
+/**
+ * Execute a git command and return stdout (or null on error)
+ * @param {string[]} args - Git command arguments
+ * @param {string} description - Description of the operation for logging
+ * @returns {string|null} - stdout string if successful, null otherwise
+ */
+export function runGitCommandOutput(args: string[], description: string): string | null;
+/**
+ * Check if the given cwd (or current directory) is a git repository
+ * @param {string} [cwd] - Directory to check (defaults to current directory at call time)
+ * @returns {boolean} - True if in a git repository, false otherwise
+ */
+export function isGitRepository(cwd?: string): boolean;

package/lib/git/utils.d.mts

@@ -0,0 +1,69 @@
+const { execSync, spawnSync } = require("child_process");
+/**
+ * Execute a git command with proper error handling and logging
+ * @param {string[]} args - Git command arguments
+ * @param {string} description - Description of the operation for logging
+ * @returns {boolean} - True if successful, false otherwise
+ */
+function runGitCommand(args, description) {
+  try {
+    console.log(`[i] ${description}`);
+    const result = spawnSync("git", args, { encoding: "utf-8" });
+    if (result.status !== 0) {
+      console.error(`[✗] Failed: ${description}`);
+      console.error(`Error: ${result.stderr || result.stdout}`);
+      return false;
+    }
+    console.log(`[✓] ${description}`);
+    return true;
+  } catch (error) {
+    console.error(`[✗] Failed: ${description}`);
+    console.error(`Error: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Check if the given cwd (or current directory) is a git repository
+ * @param {string} [cwd] - Directory to check (defaults to current directory at call time)
+ * @returns {boolean} - True if in a git repository, false otherwise
+ */
+function isGitRepository(cwd) {
+  const dir = typeof cwd === "string" ? cwd : process.cwd();
+  try {
+    execSync("git rev-parse --git-dir", { stdio: "pipe", cwd: dir });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Execute a git command and return stdout (or null on error)
+ * @param {string[]} args - Git command arguments
+ * @param {string} description - Description of the operation for logging
+ * @returns {string|null} - stdout string if successful, null otherwise
+ */
+function runGitCommandOutput(args, description) {
+  try {
+    console.log(`[i] ${description}`);
+    const result = spawnSync("git", args, { encoding: "utf-8" });
+    if (result.status !== 0) {
+      console.error(`[✗] Failed: ${description}`);
+      console.error(`Error: ${result.stderr || result.stdout}`);
+      return null;
+    }
+    console.log(`[✓] ${description}`);
+    return result.stdout.trim();
+  } catch (error) {
+    console.error(`[✗] Failed: ${description}`);
+    console.error(`Error: ${error.message}`);
+    return null;
+  }
+}
+
+module.exports = {
+  runGitCommand,
+  runGitCommandOutput,
+  isGitRepository
+};

package/lib/git/utils.d.ts

@@ -0,0 +1,69 @@
+const { execSync, spawnSync } = require("child_process");
+/**
+ * Execute a git command with proper error handling and logging
+ * @param {string[]} args - Git command arguments
+ * @param {string} description - Description of the operation for logging
+ * @returns {boolean} - True if successful, false otherwise
+ */
+function runGitCommand(args, description) {
+  try {
+    console.log(`[i] ${description}`);
+    const result = spawnSync("git", args, { encoding: "utf-8" });
+    if (result.status !== 0) {
+      console.error(`[✗] Failed: ${description}`);
+      console.error(`Error: ${result.stderr || result.stdout}`);
+      return false;
+    }
+    console.log(`[✓] ${description}`);
+    return true;
+  } catch (error) {
+    console.error(`[✗] Failed: ${description}`);
+    console.error(`Error: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Check if the given cwd (or current directory) is a git repository
+ * @param {string} [cwd] - Directory to check (defaults to current directory at call time)
+ * @returns {boolean} - True if in a git repository, false otherwise
+ */
+function isGitRepository(cwd) {
+  const dir = typeof cwd === "string" ? cwd : process.cwd();
+  try {
+    execSync("git rev-parse --git-dir", { stdio: "pipe", cwd: dir });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Execute a git command and return stdout (or null on error)
+ * @param {string[]} args - Git command arguments
+ * @param {string} description - Description of the operation for logging
+ * @returns {string|null} - stdout string if successful, null otherwise
+ */
+function runGitCommandOutput(args, description) {
+  try {
+    console.log(`[i] ${description}`);
+    const result = spawnSync("git", args, { encoding: "utf-8" });
+    if (result.status !== 0) {
+      console.error(`[✗] Failed: ${description}`);
+      console.error(`Error: ${result.stderr || result.stdout}`);
+      return null;
+    }
+    console.log(`[✓] ${description}`);
+    return result.stdout.trim();
+  } catch (error) {
+    console.error(`[✗] Failed: ${description}`);
+    console.error(`Error: ${error.message}`);
+    return null;
+  }
+}
+
+module.exports = {
+  runGitCommand,
+  runGitCommandOutput,
+  isGitRepository
+};

package/lib/git/utils.mjs

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

package/lib/git-diff.cjs

@@ -3,9 +3,10 @@
 const { execSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
-// Output path
-const CACHE_DIR = ".cache/git";
-const OUTPUT = path.join(CACHE_DIR, "diff.txt");
+const { getTempPath } = require("./binary-collections-config");
+// Output path using centralized temp directory configuration
+const OUTPUT = getTempPath("git-diff.txt");
+const CACHE_DIR = path.dirname(OUTPUT);
 // Ensure output directory exists
 if (!fs.existsSync(CACHE_DIR)) {
     fs.mkdirSync(CACHE_DIR, { recursive: true });
@@ -25,7 +26,10 @@ function showHelp() {
 function runGitDiff(command, successMessage, errorMessage) {
     try {
         console.log(`[i] Running command: ${command}`);
-        const result = execSync(command, { encoding: "utf8" });
+        const result = execSync(command, {
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024 * 10 // 10MB buffer to handle large diffs
+        });
         // If result is empty, inform user but don't treat as error
         if (!result || result.trim() === "") {
             console.log(`[i] No changes found for the specified criteria`);
@@ -47,28 +51,23 @@ function runGitDiff(command, successMessage, errorMessage) {
         process.exit(1);
     }
 }
-// Parse command line arguments
-const args = process.argv.slice(2);
+const { getArgs } = require("./utils.js");
+const args = getArgs();
+const positional = args._ || [];
 // Show help if no arguments or --help/-h is passed
-if (args[0] === "--help" || args[0] === "-h") {
+if (args.help || args.h) {
     showHelp();
 }
-// Parse options
-switch (args[0]) {
-    case "--staged-only":
-    case "-s":
-    case "-S":
-        runGitDiff("git --no-pager diff --staged", `Full staged diff saved to "${OUTPUT}"`, "Failed to save staged diff");
-        break;
-    default: {
-        // Handle specific file diff
-        const file = args[0];
-        if (!file) {
-            runGitDiff("git --no-pager diff", `Full staged diff saved to "${OUTPUT}"`, "Failed to save all diff's");
-        }
-        else {
-            runGitDiff(`git --no-pager diff --cached -- "${file}"`, `Staged diff of "${file}" saved to "${OUTPUT}"`, `Failed to generate diff for "${file}"`);
-        }
-        break;
+if (args["staged-only"] || args.s || args.S) {
+    runGitDiff("git --no-pager diff --staged", `Full staged diff saved to "${OUTPUT}"`, "Failed to save staged diff");
+}
+else {
+    // Handle specific file diff
+    const file = positional[0];
+    if (!file) {
+        runGitDiff("git --no-pager diff", `Full staged diff saved to "${OUTPUT}"`, "Failed to save all diff's");
+    }
+    else {
+        runGitDiff(`git --no-pager diff --cached -- "${file}"`, `Staged diff of "${file}" saved to "${OUTPUT}"`, `Failed to generate diff for "${file}"`);
     }
 }

package/lib/git-diff.d.mts

@@ -2,10 +2,11 @@
 const { execSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
+const { getTempPath } = require("./binary-collections-config");
 
-// Output path
-const CACHE_DIR = ".cache/git";
-const OUTPUT = path.join(CACHE_DIR, "diff.txt");
+// Output path using centralized temp directory configuration
+const OUTPUT = getTempPath("git-diff.txt");
+const CACHE_DIR = path.dirname(OUTPUT);
 
 // Ensure output directory exists
 if (!fs.existsSync(CACHE_DIR)) {
@@ -28,7 +29,10 @@ function showHelp() {
 function runGitDiff(command, successMessage, errorMessage) {
   try {
     console.log(`[i] Running command: ${command}`);
-    const result = execSync(command, { encoding: "utf8" });
+    const result = execSync(command, {
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024 * 10 // 10MB buffer to handle large diffs
+    });
 
     // If result is empty, inform user but don't treat as error
     if (!result || result.trim() === "") {
@@ -54,34 +58,27 @@ function runGitDiff(command, successMessage, errorMessage) {
   }
 }
 
-// Parse command line arguments
-const args = process.argv.slice(2);
+const { getArgs } = require("./utils.js");
+const args = getArgs();
+const positional = args._ || [];
 
 // Show help if no arguments or --help/-h is passed
-if (args[0] === "--help" || args[0] === "-h") {
+if (args.help || args.h) {
   showHelp();
 }
 
-// Parse options
-switch (args[0]) {
-  case "--staged-only":
-  case "-s":
-  case "-S":
-    runGitDiff("git --no-pager diff --staged", `Full staged diff saved to "${OUTPUT}"`, "Failed to save staged diff");
-    break;
-
-  default: {
-    // Handle specific file diff
-    const file = args[0];
-    if (!file) {
-      runGitDiff("git --no-pager diff", `Full staged diff saved to "${OUTPUT}"`, "Failed to save all diff's");
-    } else {
-      runGitDiff(
-        `git --no-pager diff --cached -- "${file}"`,
-        `Staged diff of "${file}" saved to "${OUTPUT}"`,
-        `Failed to generate diff for "${file}"`
-      );
-    }
-    break;
+if (args["staged-only"] || args.s || args.S) {
+  runGitDiff("git --no-pager diff --staged", `Full staged diff saved to "${OUTPUT}"`, "Failed to save staged diff");
+} else {
+  // Handle specific file diff
+  const file = positional[0];
+  if (!file) {
+    runGitDiff("git --no-pager diff", `Full staged diff saved to "${OUTPUT}"`, "Failed to save all diff's");
+  } else {
+    runGitDiff(
+      `git --no-pager diff --cached -- "${file}"`,
+      `Staged diff of "${file}" saved to "${OUTPUT}"`,
+      `Failed to generate diff for "${file}"`
+    );
   }
 }