initial commit

Author: RuskyDev

.gitignore

@@ -0,0 +1,6 @@
+# Node
+node_modules/
+package-lock.json
+
+# Build artifacts
+bin/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RuskyDev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,54 @@
+# @ruskydev/better-tree
+
+A fast, customizable directory tree viewer for the terminal.
+
+
+## Installation
+
+You can run it directly with `npx` (no install needed):
+
+```bash
+npx @ruskydev/better-tree --help
+````
+
+Or install globally:
+
+```bash
+npm install -g @ruskydev/better-tree
+better-tree --help
+```
+
+## Usage
+
+```bash
+better-tree [directory] [options]
+```
+
+### Options
+
+```
+--ignore <patterns...> Ignore matching files/folders (supports *, **)
+--depth <n> Limit recursion depth
+--files-only Show only files
+--dirs-only Show only directories
+--help Show this help message
+```
+
+### Examples
+
+```bash
+# Show current directory tree
+npx @ruskydev/better-tree .
+
+# Ignore node_modules and dist
+npx @ruskydev/better-tree src --ignore node_modules dist
+
+# Limit depth to 2
+npx @ruskydev/better-tree --depth 2
+
+# Show only directories
+npx @ruskydev/better-tree --dirs-only
+```
+
+## License
+This project is licensed under the [MIT License](LICENSE).

better-tree.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+import fs from "fs/promises";
+import path from "path";
+import process from "process";
+
+// ANSI colors
+const colors = {
+ reset: "\x1b[0m",
+ blue: "\x1b[34m", // directories
+ white: "\x1b[37m", // files
+ cyan: "\x1b[36m", // symlinks
+};
+
+// --------------------
+// HELP MESSAGE
+// --------------------
+function showHelp() {
+ console.log(`
+Usage: better-tree [directory] [options]
+
+Options:
+ --ignore <patterns...> Ignore matching files/folders (supports *, **)
+ --depth <n> Limit recursion depth
+ --files-only Show only files
+ --dirs-only Show only directories
+ --help Show this help message
+
+Examples:
+ better-tree .
+ better-tree src --ignore node_modules dist
+ better-tree --depth 2 --files-only
+ better-tree --dirs-only
+`);
+ process.exit(0);
+}
+
+// --------------------
+// CLI ARGUMENTS PARSING
+// --------------------
+const args = process.argv.slice(2);
+if (args.includes("--help")) showHelp();
+
+function extractOption(optionName, defaultValue = null, valueIndexOffset = 1) {
+ const index = args.indexOf(optionName);
+ if (index !== -1) {
+ const value = args[index + valueIndexOffset];
+ args.splice(index, valueIndexOffset + 1);
+ return value ?? defaultValue;
+ }
+ return defaultValue;
+}
+
+function hasFlag(flag) {
+ return args.includes(flag);
+}
+
+const ignoreIndex = args.indexOf("--ignore");
+const ignorePatterns = ignoreIndex !== -1 ? args.slice(ignoreIndex + 1) : [];
+if (ignoreIndex !== -1) args.splice(ignoreIndex);
+
+const maxDepth = parseInt(extractOption("--depth", Infinity), 10) || Infinity;
+const filesOnly = hasFlag("--files-only");
+const dirsOnly = hasFlag("--dirs-only");
+const targetDir = path.resolve(args[0] || ".");
+
+// --------------------
+// IGNORE PATTERNS
+// --------------------
+const compiledPatterns = ignorePatterns.map((pattern) => ({
+ regex: new RegExp(
+ "^" +
+ pattern
+ .replace(/\./g, "\\.")
+ .replace(/\*\*/g, ".*")
+ .replace(/\*/g, "[^/]*") +
+ "$",
+ ),
+}));
+
+function shouldIgnore(relativePath) {
+ return compiledPatterns.some(
+ ({ regex }) =>
+ regex.test(relativePath) || regex.test(path.basename(relativePath)),
+ );
+}
+
+// --------------------
+// CONCURRENCY LIMITER
+// --------------------
+let activeCount = 0;
+const queue = [];
+const maxConcurrency = 20;
+
+function limitConcurrency(task) {
+ return new Promise((resolve, reject) => {
+ const run = async () => {
+ activeCount++;
+ try {
+ const result = await task();
+ resolve(result);
+ } catch (err) {
+ reject(err);
+ } finally {
+ activeCount--;
+ if (queue.length) queue.shift()();
+ }
+ };
+ if (activeCount < maxConcurrency) {
+ run();
+ } else {
+ queue.push(run);
+ }
+ });
+}
+
+// --------------------
+// TREE PRINTING
+// --------------------
+async function printTree(dir, prefix = "", depth = 0, relativeBase = "") {
+ if (depth > maxDepth) return;
+
+ let entries;
+ try {
+ entries = await fs.readdir(dir, { withFileTypes: true });
+ } catch {
+ return;
+ }
+
+ const filteredEntries = entries
+ .map((entry) => ({
+ entry,
+ relativePath: path.join(relativeBase, entry.name).replace(/\\/g, "/"),
+ }))
+ .filter((item) => !shouldIgnore(item.relativePath))
+ .filter((item) => {
+ if (filesOnly && item.entry.isDirectory()) return false;
+ if (dirsOnly && !item.entry.isDirectory()) return false;
+ return true;
+ })
+ .sort((a, b) => a.entry.name.localeCompare(b.entry.name));
+
+ const lastIndex = filteredEntries.length - 1;
+
+ for (let i = 0; i < filteredEntries.length; i++) {
+ const { entry } = filteredEntries[i];
+ const connector = i === lastIndex ? "└── " : "├── ";
+
+ let nameColored = entry.name;
+ if (entry.isDirectory()) {
+ nameColored = colors.blue + entry.name + colors.reset;
+ } else if (entry.isSymbolicLink()) {
+ nameColored = colors.cyan + entry.name + colors.reset;
+ } else {
+ nameColored = colors.white + entry.name + colors.reset;
+ }
+
+ console.log(prefix + connector + nameColored);
+
+ if (entry.isDirectory() && !filesOnly) {
+ const nextPrefix = prefix + (i === lastIndex ? " " : "│ ");
+ await limitConcurrency(() =>
+ printTree(
+ path.join(dir, entry.name),
+ nextPrefix,
+ depth + 1,
+ filteredEntries[i].relativePath,
+ ),
+ );
+ }
+ }
+}
+
+// --------------------
+// START
+// --------------------
+await printTree(targetDir);

package.json

@@ -0,0 +1,18 @@
+{
+ "name": "@ruskydev/better-tree",
+ "version": "1.0.0",
+ "type": "module",
+ "license": "MIT",
+ "bin": {
+ "better-tree": "./bin/better-tree.min.js"
+ },
+ "scripts": {
+ "build": "npm run test && node ./scripts/build.js",
+ "test": "vitest run tests",
+ "prepare": "npm run build"
+ },
+ "devDependencies": {
+ "esbuild": "^0.23.0",
+ "vitest": "^1.6.0"
+ }
+}

scripts/build.js

@@ -0,0 +1,9 @@
+import { execSync } from "child_process";
+import { mkdirSync } from "fs";
+
+mkdirSync("bin", { recursive: true });
+
+execSync(
+ `esbuild better-tree.js --bundle --platform=node --format=esm --minify --outfile=bin/better-tree.min.js`,
+ { stdio: "inherit" },
+);

tests/better-tree.test.js

@@ -0,0 +1,59 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+
+let testDir;
+let cliPath = path.resolve("./better-tree.js");
+
+beforeAll(() => {
+ testDir = fs.mkdtempSync(path.join(os.tmpdir(), "better-tree-"));
+
+ fs.writeFileSync(path.join(testDir, "file1.txt"), "hello");
+ fs.writeFileSync(path.join(testDir, "file2.log"), "log");
+
+ fs.mkdirSync(path.join(testDir, "sub"));
+ fs.writeFileSync(path.join(testDir, "sub", "nested.txt"), "nested");
+
+ fs.mkdirSync(path.join(testDir, "node_modules"));
+ fs.writeFileSync(path.join(testDir, "node_modules", "ignore.js"), "ignore");
+});
+
+afterAll(() => {
+ fs.rmSync(testDir, { recursive: true, force: true });
+});
+
+describe("better-tree CLI", () => {
+ it("prints tree structure", () => {
+ const output = execSync(`node ${cliPath} ${testDir}`, {
+ encoding: "utf-8",
+ });
+ expect(output).toContain("file1.txt");
+ expect(output).toContain("sub");
+ });
+
+ it("respects --ignore", () => {
+ const output = execSync(
+ `node ${cliPath} ${testDir} --ignore node_modules`,
+ { encoding: "utf-8" },
+ );
+ expect(output).not.toContain("node_modules");
+ });
+
+ it("respects --files-only", () => {
+ const output = execSync(`node ${cliPath} ${testDir} --files-only`, {
+ encoding: "utf-8",
+ });
+ expect(output).toContain("file1.txt");
+ expect(output).not.toContain("sub");
+ });
+
+ it("respects --dirs-only", () => {
+ const output = execSync(`node ${cliPath} ${testDir} --dirs-only`, {
+ encoding: "utf-8",
+ });
+ expect(output).toContain("sub");
+ expect(output).not.toContain("file1.txt");
+ });
+});