binary-collections 2.0.7 → 2.0.8

package/readme.md

@@ -24,9 +24,6 @@ npm install binary-collections
 # Install globally
 npm install binary-collections -g
 
-# Install from Git
-npm install binary-collections@git+https://github.com/dimaslanjaka/bin.git
-
 # Install from release archive
 npm install binary-collections@https://github.com/dimaslanjaka/bin/raw/master/releases/bin.tgz
 ```
@@ -77,14 +74,32 @@ Create `.vscode/settings.json` to add binary tools to your PATH:
 
 | Category | Tools | Description |
 |----------|-------|-------------|
-| **Git** | `git-purge`, `git-diff`, `git-fix-encoding`, `git-reduce-size` | Git repository management and optimization |
+| **Git** | `git-purge`, `git-diff`, `git-fix`, `git-reduce-size` | Git repository management and optimization |
 | **Submodules** | `submodule`, `submodule-install`, `submodule-remove`, `submodule-token` | Git submodule operations |
 | **NPM Scripts** | `nrs`, `run-s`, `run-series`, `npm-run-series` | Run npm scripts in series with pattern matching |
-| **Package Mgmt** | `yarn-reinstall`, `package-resolutions` | Yarn package management utilities |
+| **Package Mgmt** | `yarn-reinstall`, `pkg-resolutions-updater`, `pkg-res-updater` | Yarn/package resolutions management utilities |
 | **Node.js Dev** | `find-node-modules`, `find-nodemodules`, `dev`, `prod`, `empty` | Node.js development helpers |
 | **Process Mgmt** | `kill-process`, `nodekill`, `javakill`, `del-ps` | Process management and termination |
-| **File System** | `rmfind`, `rmpath`, `rmx` | File system operations |
+| **File System** | `rmfind`, `rmpath`, `rmx`, `print-tree`, `dir-tree` | File system operations |
 | **Cleanup** | `del-nodemodules`, `del-yarncaches`, `del-gradle` | Cache and build directory cleanup |
+| **GitHub Actions** | `clean-github-actions-caches`, `clean-github-actions-cache`, `clear-github-actions-cache`, `clear-github-actions-caches`, `clear-gh-caches` | Remove old GitHub Actions caches, keep only the latest |
+
+
+---
+#### Binary List Generation & Source Code
+
+The list of available binaries and utilities is automatically generated by the build script (`build.js`).
+All CLI tools and binaries are collected from the `bin/`, `lib/`, and other relevant folders. The build process updates the `bin` field in `package.json` to reflect all available executables.
+
+Source code for utilities is located in the [`src/`](./src/) folder. To update the binary list, run:
+
+```bash
+yarn run build
+# or
+node build.js
+```
+
+This will scan the project and update `package.json` with all available binaries. The list may change as files are added or removed from the project.
 
 For a complete list of available binaries and utilities, see:
 - [Binary executables](https://github.com/dimaslanjaka/bin/tree/master/bin)
@@ -109,13 +124,42 @@ Enhanced git diff functionality:
 git-diff
 ```
 
-#### Git Encoding Fixer
-Fix git file encoding issues:
+#### Git Fix Utility
+Comprehensive Git configuration fixer for cross-platform development (replaces the old `git-fix-encoding`):
 
 ```bash
-git-fix-encoding
+git-fix                          # Apply all fixes
+git-fix --lf-only                # Force LF line endings only
+git-fix --permissions            # Ignore file permissions only
+git-fix --normalize              # Normalize existing files only
+git-fix --user                   # Configure Git user from environment
+git-fix --user NAME EMAIL        # Configure Git user with specific values
+git-fix --user --update-remote   # Also update remote URL to match user
+git-fix --user NAME EMAIL --update-remote  # Configure user and update remote URL
 ```
 
+Features:
+- Forces LF line endings (`core.autocrlf = false`)
+- Ignores file permission changes (`core.filemode = false`)
+- Sets pull strategy to false (prevents auto-rebase)
+- Normalizes existing line endings
+- Creates/updates `.gitattributes` with proper line ending rules
+- Configures Git user from environment variables or CLI arguments
+- **Non-interactive:** All configuration is now argument-driven; no interactive prompts
+- `--update-remote` flag: Update remote URL to match the configured user (for HTTPS remotes)
+
+User Configuration:
+- Environment variables: `GITHUB_USER`, `GITHUB_EMAIL`
+- CLI arguments take precedence over environment variables
+- Use `--update-remote` to update the remote URL with the configured user
+- Examples:
+  ```bash
+  git-fix --user "John Doe" "john@example.com"  # Use CLI args
+  git-fix --user --update-remote                 # Use env vars and update remote
+  git-fix --user "Jane" "jane@example.com" --update-remote  # CLI args and update remote
+  GITHUB_USER="Jane" GITHUB_EMAIL="jane@example.com" git-fix --user  # Use env vars
+  ```
+
 #### Git Repository Size Reducer
 Reduce git repository size by cleaning up history:
 
@@ -175,10 +219,11 @@ yarn-reinstall <packageName> [--dev|-D|--peer|-P|--optional|-O]
 ```
 
 #### Package Resolutions Manager
-Manage package resolutions in package.json:
+Manage package resolutions in package.json (aliases: `pkg-resolutions-updater`, `pkg-res-updater`):
 
 ```bash
-package-resolutions
+pkg-resolutions-updater
+pkg-res-updater
 ```
 
 ### Node.js Development Tools
@@ -216,6 +261,24 @@ del-ps          # Kill processes by command name
 
 ### Cleanup Tools
 
+### GitHub Actions Cache Cleaner
+
+Remove old GitHub Actions caches, keeping only the most recent cache for each prefix:
+
+```bash
+clean-github-actions-caches
+```
+
+Features:
+- Authenticates using `ACCESS_TOKEN` or `GITHUB_TOKEN` from your `.env` file
+- Automatically groups and deletes caches by prefix, keeping only the latest
+- Works for the current repository (origin remote)
+
+Environment setup:
+- Ensure your `.env` file contains `ACCESS_TOKEN` or `GITHUB_TOKEN`
+
+Source: [`src/clean-github-actions-caches.cjs`](./src/clean-github-actions-caches.cjs)
+
 #### Node Modules Cleaner
 Remove node_modules directories recursively:
 

package/src/package-resolutions-updater.mjs

@@ -0,0 +1,325 @@
+/**
+ * 📦 GitHub Package Resolver
+ *
+ * This script updates the commit hashes in `package.json`'s `resolutions` field
+ * for GitHub tarball URLs (typically using `raw/branch-name/...`) 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 for ESM and `fetch` fallback compatibility
+ *
+ * 🧩 Dependencies:
+ * - `ansi-colors` – for styled terminal output
+ * - `dotenv` – to load GitHub token from `.env`
+ *
+ * ✅ Use case:
+ * - Ensures package resolutions always use immutable SHAs instead of mutable branch names.
+ * - Helps achieve deterministic builds in monorepos or projects with internal GitHub packages.
+ */
+
+import ansiColors from "ansi-colors";
+import * as dotenv from "dotenv";
+import fs from "fs";
+import https from "https";
+import os from "os";
+import path from "path";
+
+const projectDir = process.cwd();
+const envPath = path.join(projectDir, ".env");
+
+// Load the .env file using dotenv (ESM import)
+if (fs.existsSync(envPath)) dotenv.config({ path: envPath });
+
+// 📌 Static override rules
+const specialPackageOverrides = [
+  // SBG packages
+  { pkg: "sbg-utility", branch: "sbg-utility", repo: "static-blog-generator", owner: "dimaslanjaka" },
+  { pkg: "sbg-api", branch: "sbg-api", repo: "static-blog-generator", owner: "dimaslanjaka" },
+  { pkg: "instant-indexing", branch: "instant-indexing", repo: "static-blog-generator", owner: "dimaslanjaka" },
+  { pkg: "sbg-server", branch: "master", repo: "static-blog-generator", owner: "dimaslanjaka" },
+  { pkg: "sbg-cli", branch: "master", repo: "static-blog-generator", owner: "dimaslanjaka" },
+  { pkg: "static-blog-generator", branch: "master", repo: "static-blog-generator", owner: "dimaslanjaka" },
+  // Hexo family
+  { pkg: "hexo", branch: "monorepo-v7", repo: "hexo", owner: "dimaslanjaka" },
+  { pkg: "hexo-util", branch: "monorepo-v7", repo: "hexo", owner: "dimaslanjaka" },
+  { pkg: "warehouse", branch: "monorepo-v7", repo: "hexo", owner: "dimaslanjaka" },
+  { pkg: "hexo-server", branch: "monorepo-v7", repo: "hexo", owner: "dimaslanjaka" },
+  { pkg: "hexo-log", branch: "monorepo-v7", repo: "hexo", owner: "dimaslanjaka" },
+  { pkg: "hexo-front-matter", branch: "monorepo-v7", repo: "hexo", owner: "dimaslanjaka" },
+  { pkg: "hexo-cli", branch: "monorepo-v7", repo: "hexo", owner: "dimaslanjaka" },
+  { pkg: "hexo-asset-link", branch: "monorepo-v7", repo: "hexo", owner: "dimaslanjaka" },
+  { pkg: "hexo-post-parser", branch: "pre-release", repo: "hexo-post-parser", owner: "dimaslanjaka" },
+  { pkg: "hexo-seo", branch: "pre-release", repo: "hexo-seo", owner: "dimaslanjaka" },
+  { pkg: "hexo-is", branch: "master", repo: "hexo-is", owner: "dimaslanjaka" },
+  { pkg: "markdown-it", branch: "master", repo: "markdown-it", owner: "dimaslanjaka" },
+  { pkg: "hexo-renderers", branch: "pre-release", repo: "hexo-renderers", owner: "dimaslanjaka" },
+  { pkg: "hexo-shortcodes", branch: "pre-release", repo: "hexo-shortcodes", owner: "dimaslanjaka" },
+  { pkg: "google-news-sitemap", branch: "master", repo: "google-news-sitemap", owner: "dimaslanjaka" },
+  { pkg: "git-command-helper", branch: "pre-release", repo: "git-command-helper", owner: "dimaslanjaka" },
+  {
+    pkg: "nodejs-package-types",
+    branch: "main",
+    repo: "nodejs-package-types",
+    owner: "dimaslanjaka"
+  },
+  { pkg: "cross-spawn", branch: "private", repo: "node-cross-spawn", owner: "dimaslanjaka" },
+  { pkg: "hexo-generator-redirect", branch: "master", repo: "hexo-generator-redirect", owner: "dimaslanjaka" },
+  { pkg: "binary-collections", branch: "master", repo: "bin", owner: "dimaslanjaka" },
+  { pkg: "@types/hexo", branch: "monorepo-v7", repo: "hexo", owner: "dimaslanjaka" },
+  { pkg: "@types/git-command-helper", branch: "pre-release", repo: "git-command-helper", owner: "dimaslanjaka" }
+];
+
+// --- Optimized: Load package.json once at the top ---
+const pkgPath = path.join(process.cwd(), "package.json");
+let pkg;
+try {
+  pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+} catch (e) {
+  console.error(ansiColors.red(`Failed to read package.json: ${e.message}`));
+  process.exit(1);
+}
+
+// --- Use a random User-Agent for GitHub API requests ---
+const 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)"
+];
+
+// --- User-Agent persistence in system temp folder ---
+const userAgentDir = path.join(os.tmpdir(), "nodejs");
+const userAgentFile = path.join(userAgentDir, "useragent.txt");
+let 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) {
+  // fallback to random if any error
+  selectedUserAgent = GITHUB_USER_AGENTS[Math.floor(Math.random() * GITHUB_USER_AGENTS.length)];
+}
+
+/**
+ * Fetch JSON from a URL with GitHub headers.
+ * @param {string} url
+ * @returns {Promise<any>}
+ */
+function fetchJson(url) {
+  const headers = {
+    "User-Agent": selectedUserAgent,
+    Accept: "application/vnd.github.v3+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    ...(process.env.GITHUB_TOKEN ? { Authorization: `token ${process.env.GITHUB_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"}\nURL: ${url}`)
+              );
+            }
+            resolve(json);
+          } catch {
+            reject(new Error(`Invalid JSON from: ${url}`));
+          }
+        });
+      })
+      .on("error", reject);
+  });
+}
+
+/**
+ * Get latest commit SHA from a specific branch.
+ */
+async function getLatestCommit(owner, repo, branch = "main") {
+  const url = `https://api.github.com/repos/${owner}/${repo}/commits/${branch}`;
+  const json = await fetchJson(url);
+
+  const sha = json.sha;
+  const dateStr = json.commit?.committer?.date || json.commit?.author?.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()
+  };
+}
+
+/**
+ * Get latest commit SHA from all branches and pick the latest.
+ */
+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 }) => {
+      const commitSha = commit?.sha;
+      if (!commitSha) {
+        console.warn(`No commit SHA for '${owner}/${repo}' branch: ${name}`);
+        return { branch: name, sha: "", date: new Date(0) };
+      }
+
+      try {
+        const commitData = await fetchJson(`https://api.github.com/repos/${owner}/${repo}/commits/${commitSha}`);
+        const dateStr = commitData.commit?.committer?.date || commitData.commit?.author?.date;
+        const date = dateStr ? new Date(dateStr) : 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: new Date(0) };
+      }
+    })
+  );
+
+  const latest = commits.reduce((a, b) => (a.date > b.date ? a : b), { date: new Date(0) });
+
+  return {
+    owner,
+    repo,
+    branch: latest.branch,
+    sha: latest.sha,
+    date: latest.date.toISOString()
+  };
+}
+
+/**
+ * Replace the branch or commit in a GitHub raw URL with the latest hash.
+ */
+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, path] = match;
+  return `https://github.com/${owner}/${repo}/raw/${latestHash}/${path}`;
+}
+
+/**
+ * Parse GitHub URLs and extract owner, repo, branch, and original URL.
+ */
+function parseGitHubUrl(url) {
+  const ghRepoRoot = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/?$/;
+  const ghTreeOrBlob = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/(tree|blob)\/([^/]+(?:\/[^/]+)*)/;
+  const ghRaw = /^https:\/\/raw\.githubusercontent\.com\/([^/]+)\/([^/]+)\/([^/]+)(\/.+)?$/;
+  const ghDotComRaw = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/raw\/([^/]+)\/.+/;
+
+  let match;
+
+  if ((match = url.match(ghRaw))) {
+    const [, owner, repo, branch] = match;
+    return { owner, repo, branch, url };
+  }
+
+  if ((match = url.match(ghDotComRaw))) {
+    const [, owner, repo, branch] = match;
+    return { owner, repo, branch, url };
+  }
+
+  if ((match = url.match(ghTreeOrBlob))) {
+    const [, owner, repo, , branchPath] = match;
+    return { owner, repo, branch: branchPath, url };
+  }
+
+  if ((match = url.match(ghRepoRoot))) {
+    const [, owner, repo] = match;
+    return { owner, repo, url };
+  }
+
+  throw new Error(`Unsupported GitHub URL: ${url}`);
+}
+
+// --- Main logic ---
+(async () => {
+  const entries = Object.entries(pkg.resolutions || {});
+  if (entries.length === 0) {
+    console.log(ansiColors.yellow("No resolutions found in package.json"));
+    return;
+  }
+  console.log(`Processing ${entries.length} resolution(s)...`);
+  const updates = [];
+  for (const [currentPkgName, url] of entries) {
+    // Validate if URL is a GitHub URL
+    let repo;
+    try {
+      repo = parseGitHubUrl(url);
+      console.log(`✅ Valid GitHub URL for ${ansiColors.cyan(currentPkgName)}: ${url}`);
+    } catch (error) {
+      console.log(`⏭️  Skipping ${ansiColors.yellow(currentPkgName)}: ${error.message}`);
+      continue;
+    }
+    try {
+      const override = specialPackageOverrides.find((p) => p.pkg === currentPkgName);
+      const latest = override
+        ? await getLatestCommit(override.owner, override.repo, override.branch)
+        : await getLatestCommitAcrossBranches(repo.owner, repo.repo);
+      const new_url = replaceRawWithLatestHash(url, latest.sha);
+      updates.push({
+        currentPkgName,
+        url,
+        new_url,
+        repo,
+        latest
+      });
+    } catch (error) {
+      console.log(`❌ Failed to process ${ansiColors.red(currentPkgName)}: ${error.message}`);
+    }
+  }
+  if (updates.length === 0) {
+    console.log(ansiColors.yellow("No GitHub URLs were processed"));
+    return;
+  }
+  console.log(`\n📝 Applying updates to ${updates.length} GitHub URL(s)...`);
+  let changed = false;
+  for (const { currentPkgName, url, new_url, repo, latest } of updates) {
+    if (url !== new_url) {
+      console.log(`\n${ansiColors.cyan(currentPkgName)}:`);
+      console.log("  from:", url.replace(repo.branch, ansiColors.red(repo.branch)));
+      console.log("    to:", new_url.replace(latest.sha, ansiColors.green(latest.sha)));
+      pkg.resolutions[currentPkgName] = new_url;
+      changed = true;
+    } else {
+      console.log(`\n${ansiColors.cyan(currentPkgName)}: ${ansiColors.gray("already up-to-date")}`);
+    }
+  }
+  if (changed) {
+    try {
+      fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+      console.log(`\n✅ package.json updated successfully`);
+    } catch (e) {
+      console.error(ansiColors.red(`Failed to write package.json: ${e.message}`));
+      process.exit(1);
+    }
+  } else {
+    console.log(ansiColors.green("No changes to package.json were necessary."));
+  }
+})();

package/src/print-directory-tree.cjs

@@ -0,0 +1,234 @@
+const fs = require("fs").promises;
+const path = require("path");
+const crypto = require("crypto");
+const { execSync } = require("child_process");
+const glob = require("glob");
+const { getArgs } = require("./utils.js");
+const sbgUtil = require("sbg-utility");
+const dotenv = require("dotenv");
+
+const projectDir = process.cwd();
+const envPath = path.join(projectDir, ".env");
+
+// Load the .env file using dotenv (ESM import)
+if (fs.existsSync(envPath)) dotenv.config({ path: envPath });
+
+// Parse CLI arguments
+const argv = getArgs();
+
+// Main logic wrapped in an async function
+async function main() {
+  // Determine output file from CLI args
+  let relativeOutputFile = "tmp/directory-structure.txt";
+  if (argv.output || argv.o) {
+    relativeOutputFile = argv.output || argv.o;
+  }
+  // If not absolute, resolve relative to projectDir
+  const outputFile = path.isAbsolute(relativeOutputFile)
+    ? relativeOutputFile
+    : path.join(projectDir, relativeOutputFile);
+
+  // Create or clear the hash file
+  sbgUtil.writefile(outputFile, "");
+
+  /**
+   * List of file extensions to include
+   * @type {string[]}
+   */
+  let extensions = [];
+  if (argv.ext) {
+    extensions = argv.ext
+      .split(",")
+      .map((e) => e.trim().replace(/^\./, ""))
+      .filter(Boolean);
+  }
+
+  // Directories to exclude
+  let excludeDirs = [
+    "node_modules",
+    "vendor",
+    "venv",
+    ".venv",
+    ".git",
+    ".hg",
+    ".svn",
+    ".idea",
+    ".vscode",
+    "dist",
+    "build",
+    "out",
+    "coverage",
+    ".DS_Store"
+  ];
+  if (argv.exclude) {
+    const userExcludes = argv.exclude
+      .split(",")
+      .map((d) => d.trim())
+      .filter(Boolean);
+    if (argv["override-exclude"] || argv.we) {
+      // Override the default excludes with user-provided ones
+      excludeDirs = userExcludes;
+    } else {
+      // Append user-provided excludes to the default ones
+      excludeDirs = excludeDirs.concat(userExcludes);
+    }
+  }
+
+  // Convert excludeDirs into glob ignore patterns
+  const ignorePatterns = excludeDirs.map((dir) => `**/${dir}/**`);
+
+  // Initialize an array to hold the formatted outputs
+  let hashArray = [];
+
+  // Helper function to hash and add file if not already processed
+  const processedFiles = new Set();
+  /**
+   * Hashes a file and pushes its relative path and hash to the hashArray.
+   * @param {string} file - The absolute path to the file.
+   * @returns {Promise<void>} Resolves when the file has been processed and added to hashArray.
+   */
+  async function hashAndPush(file) {
+    if (processedFiles.has(file)) return;
+    processedFiles.add(file);
+    let relativePath = path.relative(projectDir, file);
+    relativePath = relativePath.split(path.sep).join("/");
+    try {
+      const stats = await fs.stat(file);
+      const pseudoHash = `${stats.size}-${stats.mtimeMs}`;
+      const hash = crypto.createHash("sha256").update(pseudoHash).digest("hex");
+      hashArray.push(`${relativePath} ${hash.slice(0, 8)}`);
+    } catch (err) {
+      console.error(`Error processing file: ${file}`, err instanceof Error ? err.message : "<unknown error>");
+      if (err && err.code === "ENOENT") {
+        hashArray.push(`${relativePath} <file not found>`);
+      } else {
+        hashArray.push(`${relativePath} <error: ${err && err.code ? `code ${err.code}` : "unknown"}>`);
+      }
+    }
+  }
+
+  // Collect all files to process (extensions + special files)
+  const initialFiles = [
+    path.join(projectDir, "package.json"),
+    path.join(projectDir, "composer.json"),
+    path.join(projectDir, "requirements.txt")
+  ];
+  let patterns = [];
+  if (argv.pattern) {
+    if (Array.isArray(argv.pattern)) {
+      patterns = argv.pattern.map((p) => p.trim()).filter(Boolean);
+    } else {
+      patterns = [argv.pattern.trim()];
+    }
+  } else if (extensions.length === 0) {
+    patterns = ["**/*.*"];
+  } else {
+    patterns = extensions.map((ext) => `**/*.${ext}`);
+  }
+  const globFiles = glob.sync(patterns.length === 1 ? patterns[0] : `{${patterns.join(",")}}`, {
+    cwd: projectDir,
+    ignore: ignorePatterns,
+    absolute: true,
+    nodir: true
+  });
+  const allFiles = new Set([...initialFiles, ...globFiles]);
+
+  // Hash all unique files
+  await Promise.all(Array.from(allFiles).map(hashAndPush));
+
+  // Sort the hashArray by file paths
+  hashArray.sort((a, b) => a.localeCompare(b));
+
+  /**
+   * Generates a directory/file tree string from a hash array of file paths and hashes.
+   *
+   * @param {string[]} hashArray - Array of strings in the format 'relative/path/to/file hash'.
+   * @returns {string} The directory/file tree as a string, with file hashes.
+   */
+  function getFileTreeString(hashArray) {
+    const tree = {};
+    // Map file paths to hashes for quick lookup
+    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; // file
+        } else {
+          current[part] = current[part] || {};
+          current = current[part];
+        }
+      }
+    }
+    /**
+     * Recursively builds the tree string for a given node.
+     *
+     * @param {Object} node - The current node in the tree.
+     * @param {string} prefix - The prefix for the current tree level.
+     * @param {string} parentPath - The path to the current node.
+     * @returns {string[]} Array of lines representing the tree structure.
+     */
+    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 ? "└── " : "├── ";
+        const currentPath = parentPath ? parentPath + "/" + key : key;
+        if (node[key] === null) {
+          // file: show hash
+          lines.push(prefix + branch + key + " [" + (hashMap[currentPath] || "") + "]");
+        } else {
+          lines.push(prefix + branch + key + "/");
+          lines = lines.concat(printNode(node[key], prefix + (isLast ? "    " : "│   "), currentPath));
+        }
+      });
+      return lines;
+    }
+    return printNode(tree, "", "").join("\n");
+  }
+
+  // Write directory/file tree to the output file (hashes are included in the tree)
+  const fileTreeString = getFileTreeString(hashArray);
+  await fs.writeFile(outputFile, fileTreeString + "\n", "utf-8");
+
+  // Add the hash file to the commit if --git-add is present
+  if (argv["git-add"]) {
+    execSync(`git add ${relativeOutputFile}`);
+    console.log(`Directory tree written to ${relativeOutputFile} and staged for git.`);
+  } else {
+    console.log(`Directory tree written to ${relativeOutputFile}.`);
+  }
+}
+
+if (argv.help || argv.h) {
+  console.log(`
+Usage: node print-directory-tree.cjs [options]
+
+Options:
+  --output, -o <file>           Output file path (default: tmp/directory-structure.txt)
+  --ext <exts>                  Comma-separated list of file extensions (no dot, e.g. js,ts)
+  --pattern <glob>              Glob pattern(s) for files (can be repeated)
+  --exclude <dirs>              Comma-separated list of directories to exclude (appends to default)
+  --override-exclude, -we       Override default exclude directories with --exclude
+  --git-add                     Add output file to git after writing
+  --help, -h                    Show this help message
+
+Examples:
+  node print-directory-tree.cjs --ext=js,ts
+  node print-directory-tree.cjs --pattern=src/**/*.js --pattern=test/**/*.js
+  node print-directory-tree.cjs --exclude=dist,build
+  node print-directory-tree.cjs --output=tmp/tree.txt
+`);
+  process.exit(0);
+}
+
+// Execute the main function
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});