binary-collections 2.0.7 → 2.0.8

package/lib/package-resolutions-updater.mjs

@@ -0,0 +1,316 @@
+/**
+ * 📦 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.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 = Object.assign({ "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 (_a) {
+                    reject(new Error(`Invalid JSON from: ${url}`));
+                }
+            });
+        })
+            .on("error", reject);
+    });
+}
+/**
+ * Get latest commit SHA from a specific branch.
+ */
+function getLatestCommit(owner_1, repo_1) {
+    return __awaiter(this, arguments, void 0, function* (owner, repo, branch = "main") {
+        var _a, _b, _c, _d;
+        const url = `https://api.github.com/repos/${owner}/${repo}/commits/${branch}`;
+        const json = yield fetchJson(url);
+        const sha = json.sha;
+        const dateStr = ((_b = (_a = json.commit) === null || _a === void 0 ? void 0 : _a.committer) === null || _b === void 0 ? void 0 : _b.date) || ((_d = (_c = json.commit) === null || _c === void 0 ? void 0 : _c.author) === null || _d === void 0 ? void 0 : _d.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.
+ */
+function getLatestCommitAcrossBranches(owner, repo) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const branches = yield fetchJson(`https://api.github.com/repos/${owner}/${repo}/branches`);
+        const commits = yield Promise.all(branches.map((_a) => __awaiter(this, [_a], void 0, function* ({ name, commit }) {
+            var _b, _c, _d, _f;
+            const commitSha = commit === null || commit === void 0 ? void 0 : 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 = yield fetchJson(`https://api.github.com/repos/${owner}/${repo}/commits/${commitSha}`);
+                const dateStr = ((_c = (_b = commitData.commit) === null || _b === void 0 ? void 0 : _b.committer) === null || _c === void 0 ? void 0 : _c.date) || ((_f = (_d = commitData.commit) === null || _d === void 0 ? void 0 : _d.author) === null || _f === void 0 ? void 0 : _f.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 ---
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    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
+                ? yield getLatestCommit(override.owner, override.repo, override.branch)
+                : yield 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/lib/print-directory-tree.cjs

@@ -0,0 +1,241 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 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.
+         */
+        function hashAndPush(file) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (processedFiles.has(file))
+                    return;
+                processedFiles.add(file);
+                let relativePath = path.relative(projectDir, file);
+                relativePath = relativePath.split(path.sep).join("/");
+                try {
+                    const stats = yield 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
+        yield 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);
+        yield 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);
+});

package/lib/print-directory-tree.d.cts

@@ -0,0 +1 @@
+export {};