@skapxd/tree 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Manraj Singh
+
+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.

package/README.md

@@ -0,0 +1,99 @@
+# @skapxd/tree
+
+[![CI](https://github.com/skapxd/tree/actions/workflows/ci.yml/badge.svg)](https://github.com/skapxd/tree/actions/workflows/ci.yml)
+[![npm version](https://badge.fury.io/js/@skapxd%2Ftree.svg)](https://badge.fury.io/js/@skapxd%2Ftree)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Visualize your directory structure with professional ASCII art.**
+
+A modern, TypeScript-based CLI tool designed to generate clean, tree-like diagrams of your folder structure. It is optimized for **Documentation** and **AI Context**, providing a token-efficient overview of your codebase.
+
+## 🚀 Quick Start (No Installation)
+
+The fastest way to use it is with `npx`. It works instantly in any directory.
+
+```bash
+# View current directory
+npx @skapxd/tree
+
+# View a specific folder
+npx @skapxd/tree ./src
+```
+
+## 🤖 Optimized for AI Agents & LLMs
+
+This tool is specifically designed to help AI Agents (like ChatGPT, Claude, Gemini, or GitHub Copilot) understand your project architecture **without consuming massive context windows**.
+
+When you need an AI to understand your project structure, run this command and paste the output:
+
+```bash
+npx @skapxd/tree ./src
+```
+
+**Why is this better for AI?**
+*   **Context Focus:** By targeting `./src`, you provide the AI with only the relevant business logic, avoiding noise.
+*   **Token Efficient:** Uses minimal characters to convey maximum structural information.
+*   **High Contrast:** Distinct separation between folders and files helps LLMs parse the hierarchy accurately.
+
+## 🎨 Example Output
+
+```text
+src
+├── index.ts
+├── cli.ts
+├── utils
+│   ├── parser.ts
+│   └── drawer.ts
+└── components
+    ├── Button.tsx
+    └── Header.tsx
+```
+
+## ⚙️ Options
+
+| Flag | Description | Example |
+| :--- | :--- | :--- |
+| `[dir]` | (Positional) Directory to scan. Defaults to current. | `npx @skapxd/tree ./src` |
+| `-i`, `--ignore` | Regex pattern to ignore files/folders. | `-i "node_modules|dist"` |
+| `-f`, `--only-folder` | Output only directories, hiding files. | `-f` |
+| `-e`, `--export` | Save the output to a text file. | `-e structure.txt` |
+| `-d`, `--directory` | (Alternative) Specify directory via flag. | `-d ./src` |
+
+## 📦 Installation (Optional)
+
+If you use it frequently, you can install it globally:
+
+```bash
+npm install -g @skapxd/tree
+# or
+pnpm add -g @skapxd/tree
+```
+
+Then run it simply as:
+```bash
+tree
+# or
+npx @skapxd/tree
+```
+
+## 🛠️ Development
+
+This project uses **TypeScript**, **Tsup** for bundling, and **Vitest** for testing.
+
+```bash
+# Install dependencies
+yarn install
+
+# Run in development mode
+yarn dev
+
+# Build for production
+yarn build
+
+# Run tests
+yarn test
+```
+
+## 📄 License
+
+MIT

package/dist/cli.cjs

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+var import_fs2 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+
+// src/parser.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+
+// src/utils.ts
+function sortDir(arr) {
+  let i = arr.length - 1;
+  while (i >= 0) {
+    if (typeof arr[i] === "object") {
+      const obj = arr.splice(i, 1);
+      arr.push(obj[0]);
+    }
+    i--;
+  }
+  return arr;
+}
+function parseIgnoreOption(ignoreStr) {
+  if (!ignoreStr) return null;
+  let cleanStr = ignoreStr.replace(/^\s*|\s*$/g, "");
+  if (/^\/.+\/$/.test(cleanStr)) {
+    cleanStr = cleanStr.replace(/(^\/)|(\/$)/g, "");
+    return new RegExp(cleanStr, "");
+  } else {
+    return new RegExp(cleanStr, "");
+  }
+}
+
+// src/parser.ts
+function dirToJson(dirPath, ignoreRegex, onlyFolder) {
+  let stats;
+  try {
+    stats = import_fs.default.lstatSync(dirPath);
+  } catch (e) {
+    return null;
+  }
+  if (stats.isDirectory()) {
+    let dir = import_fs.default.readdirSync(dirPath);
+    if (ignoreRegex) {
+      dir = dir.filter((val) => {
+        return !ignoreRegex.test(val);
+      });
+    }
+    const children = dir.filter((child) => {
+      const childPath = import_path.default.join(dirPath, child);
+      try {
+        const childStats = import_fs.default.lstatSync(childPath);
+        return onlyFolder ? childStats.isDirectory() : true;
+      } catch {
+        return false;
+      }
+    }).map((child) => {
+      return dirToJson(import_path.default.join(dirPath, child), ignoreRegex, onlyFolder);
+    }).filter((c) => c !== null);
+    const dirName = import_path.default.basename(dirPath);
+    const structure = {};
+    structure[dirName] = sortDir(children);
+    return structure;
+  } else {
+    return import_path.default.basename(dirPath);
+  }
+}
+
+// src/drawer.ts
+var characters = {
+  border: "\u2502   ",
+  contain: "\u251C\u2500\u2500 ",
+  last: "\u2514\u2500\u2500 "
+};
+var outputString = "";
+function resetOutput() {
+  outputString = "";
+}
+function drawDirTree(name, children, prefix = "", isLast = true, isRoot = false) {
+  const { border, contain, last } = characters;
+  const branch = isRoot ? "" : isLast ? last : contain;
+  outputString += (outputString ? "\n" : "") + prefix + branch + name;
+  if (Array.isArray(children)) {
+    const newPrefix = isRoot ? "" : prefix + (isLast ? "    " : border);
+    children.forEach((child, idx) => {
+      const childIsLast = idx === children.length - 1;
+      if (typeof child === "string") {
+        outputString += "\n" + newPrefix + (childIsLast ? last : contain) + child;
+      } else {
+        const keys = Object.keys(child);
+        if (keys.length > 0) {
+          const subName = keys[0];
+          const subChildren = child[subName];
+          drawDirTree(subName, subChildren, newPrefix, childIsLast, false);
+        }
+      }
+    });
+  }
+}
+function generateTreeString(structure) {
+  resetOutput();
+  if (typeof structure === "string") {
+    return structure;
+  }
+  const rootName = Object.keys(structure)[0];
+  if (rootName) {
+    const children = structure[rootName];
+    drawDirTree(rootName, children, "", true, true);
+  }
+  return outputString;
+}
+
+// src/index.ts
+var import_path2 = __toESM(require("path"));
+function tree(options) {
+  const ignoreRegex = parseIgnoreOption(options.ignore);
+  const targetPath = import_path2.default.resolve(options.directory);
+  const structure = dirToJson(targetPath, ignoreRegex, options.onlyFolder);
+  if (!structure) {
+    return null;
+  }
+  return generateTreeString(structure);
+}
+
+// src/cli.ts
+var pkgPath = import_path3.default.join(__dirname, "../package.json");
+var version = "0.0.0";
+try {
+  const pkg = JSON.parse(import_fs2.default.readFileSync(pkgPath, "utf-8"));
+  version = pkg.version;
+} catch {
+}
+import_commander.program.version(version).argument("[directory]", "Directory to generate structure tree").option("-d, --directory <dir>", "Specify a directory (alternative to positional argument)").option("-i, --ignore [ig]", "You can ignore specific directory name").option("-e, --export [epath]", "export into file").option("-f, --only-folder", "output folder only").action((dirArg, options) => {
+  const targetDir = dirArg || options.directory || process.cwd();
+  const output = tree({
+    directory: targetDir,
+    ignore: options.ignore,
+    onlyFolder: options.onlyFolder
+  });
+  if (!output) {
+    console.error(`Error: Could not read directory "${targetDir}"`);
+    process.exit(1);
+  }
+  console.log(output);
+  if (options.export) {
+    import_fs2.default.writeFile(options.export, output, (err) => {
+      if (err) throw err;
+      console.log("\n\nThe result has been saved into " + options.export);
+    });
+  }
+});
+import_commander.program.parse(process.argv);
+//# sourceMappingURL=cli.cjs.map

package/dist/cli.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli.ts","../src/parser.ts","../src/utils.ts","../src/drawer.ts","../src/index.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { program } from 'commander';\nimport fs from 'fs';\nimport path from 'path';\nimport { tree } from './index';\n\n// We need to read package.json version. \n// In TS/ESM, import assertions are the way, or reading file sync.\n// For simplicity and compatibility, we'll read it.\nconst pkgPath = path.join(__dirname, '../package.json');\nlet version = '0.0.0';\ntry {\n    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));\n    version = pkg.version;\n} catch {\n    // ignore\n}\n\nprogram\n  .version(version)\n  .argument('[directory]', 'Directory to generate structure tree')\n  .option('-d, --directory <dir>', 'Specify a directory (alternative to positional argument)')\n  .option('-i, --ignore [ig]', 'You can ignore specific directory name')\n  .option('-e, --export [epath]', 'export into file')\n  .option('-f, --only-folder', 'output folder only')\n  .action((dirArg, options) => {\n    const targetDir = dirArg || options.directory || process.cwd();\n\n    const output = tree({\n      directory: targetDir,\n      ignore: options.ignore,\n      onlyFolder: options.onlyFolder,\n    });\n\n    if (!output) {\n      console.error(`Error: Could not read directory \"${targetDir}\"`);\n      process.exit(1);\n    }\n\n    // Output to console\n    console.log(output);\n\n    // Export to file if requested\n    if (options.export) {\n      fs.writeFile(options.export, output, (err) => {\n        if (err) throw err;\n        console.log('\\n\\nThe result has been saved into ' + options.export);\n      });\n    }\n  });\n\nprogram.parse(process.argv);\n","import fs from 'fs';\nimport path from 'path';\nimport { sortDir } from './utils';\n\nexport type TreeStructure = { [key: string]: (string | TreeStructure)[] } | string;\n\n/**\n * Recursively scans a directory and returns a JSON-like structure.\n * @param dirPath - The path to scan.\n * @param ignoreRegex - The regex to filter file/folder names.\n * @param onlyFolder - If true, only include directories.\n */\nexport function dirToJson(\n  dirPath: string,\n  ignoreRegex: RegExp | null,\n  onlyFolder?: boolean\n): TreeStructure | null {\n  let stats: fs.Stats;\n  try {\n    stats = fs.lstatSync(dirPath);\n  } catch (e) {\n    return null;\n  }\n\n  if (stats.isDirectory()) {\n    let dir = fs.readdirSync(dirPath);\n\n    if (ignoreRegex) {\n      dir = dir.filter((val) => {\n        return !ignoreRegex.test(val);\n      });\n    }\n\n    // Map children to their structure\n    const children = dir\n      .filter((child) => {\n        const childPath = path.join(dirPath, child);\n        try {\n            const childStats = fs.lstatSync(childPath);\n            return onlyFolder ? childStats.isDirectory() : true;\n        } catch {\n            return false;\n        }\n      })\n      .map((child) => {\n        return dirToJson(path.join(dirPath, child), ignoreRegex, onlyFolder);\n      })\n      .filter((c): c is TreeStructure => c !== null); // Filter out nulls\n\n    const dirName = path.basename(dirPath);\n    const structure: TreeStructure = {};\n    // @ts-expect-error - sortDir returns (string|object)[], compatible with TreeStructure's array\n    structure[dirName] = sortDir(children);\n    return structure;\n  } else {\n    return path.basename(dirPath);\n  }\n}\n","/**\n * Sorts directory contents so that files come before folders.\n * Objects (directories) are put at the end.\n */\nexport function sortDir(arr: (string | object)[]): (string | object)[] {\n  let i = arr.length - 1;\n  while (i >= 0) {\n    if (typeof arr[i] === 'object') {\n      const obj = arr.splice(i, 1);\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      arr.push(obj[0]!);\n    }\n    i--;\n  }\n  return arr;\n}\n\n/**\n * Parses the ignore argument string into a RegExp object.\n * @param ignoreStr - The string passed via CLI (e.g. \"node_modules|dist\")\n */\nexport function parseIgnoreOption(ignoreStr?: string): RegExp | null {\n  if (!ignoreStr) return null;\n\n  let cleanStr = ignoreStr.replace(/^\\s*|\\s*$/g, '');\n\n  // Check if it's already a regex format like /node_modules/\n  if (/^\\/.+\\/$/.test(cleanStr)) {\n    cleanStr = cleanStr.replace(/(^\\/)|(\\/$)/g, '');\n    return new RegExp(cleanStr, '');\n  } else {\n    // Treat simple strings with pipes as regex OR, without escaping special chars excessively\n    // to allow user provided regex-like strings (e.g. \"node_modules|.git\")\n    return new RegExp(cleanStr, '');\n  }\n}\n","import { type TreeStructure } from './parser';\n\nconst characters = {\n  border: '│   ',\n  contain: '├── ',\n  last: '└── ',\n};\n\nlet outputString = '';\n\nfunction resetOutput() {\n  outputString = '';\n}\n\n/**\n * Recursive function to draw the tree structure.\n */\nfunction drawDirTree(\n  name: string,\n  children: (string | TreeStructure)[],\n  prefix = '',\n  isLast = true,\n  isRoot = false\n) {\n  const { border, contain, last } = characters;\n  const branch = isRoot ? '' : isLast ? last : contain;\n\n  outputString += (outputString ? '\\n' : '') + prefix + branch + name;\n\n  if (Array.isArray(children)) {\n    const newPrefix = isRoot ? '' : prefix + (isLast ? '    ' : border);\n    children.forEach((child, idx) => {\n      const childIsLast = idx === children.length - 1;\n      if (typeof child === 'string') {\n        outputString += '\\n' + newPrefix + (childIsLast ? last : contain) + child;\n      } else {\n        // child is { subName: [subChildren] }\n        const keys = Object.keys(child);\n        if (keys.length > 0) {\n          const subName = keys[0] as string;\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          const subChildren = (child as any)[subName];\n          drawDirTree(subName, subChildren, newPrefix, childIsLast, false);\n        }\n      }\n    });\n  }\n}\n\n/**\n * Main entry point to generate the tree string.\n */\nexport function generateTreeString(structure: TreeStructure): string {\n  resetOutput();\n\n  // If it's just a single file (string), return it\n  if (typeof structure === 'string') {\n    return structure;\n  }\n\n  // It's a directory object { rootName: [...] }\n  const rootName = Object.keys(structure)[0];\n  if (rootName) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const children = (structure as any)[rootName];\n      drawDirTree(rootName, children, '', true, true);\n  }\n\n  return outputString;\n}\n","// Public API exports\nexport * from './parser';\nexport * from './drawer';\nexport * from './utils';\n\n// Re-export main functionality for programmatic use\nimport path from 'path';\nimport { dirToJson } from './parser';\nimport { generateTreeString } from './drawer';\nimport { parseIgnoreOption } from './utils';\n\nexport type TreeOptions = {\n  directory: string;\n  ignore?: string;\n  onlyFolder?: boolean;\n};\n\n/**\n * Generates an ASCII tree string for the given directory.\n */\nexport function tree(options: TreeOptions): string | null {\n  const ignoreRegex = parseIgnoreOption(options.ignore);\n  const targetPath = path.resolve(options.directory);\n\n  const structure = dirToJson(targetPath, ignoreRegex, options.onlyFolder);\n\n  if (!structure) {\n    return null;\n  }\n\n  return generateTreeString(structure);\n}\n"],"mappings":"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","names":["import_fs","import_path","fs","path","import_path","path","path","fs"]}

package/dist/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.mjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { program } from "commander";
+import fs2 from "fs";
+import path3 from "path";
+
+// src/parser.ts
+import fs from "fs";
+import path from "path";
+
+// src/utils.ts
+function sortDir(arr) {
+  let i = arr.length - 1;
+  while (i >= 0) {
+    if (typeof arr[i] === "object") {
+      const obj = arr.splice(i, 1);
+      arr.push(obj[0]);
+    }
+    i--;
+  }
+  return arr;
+}
+function parseIgnoreOption(ignoreStr) {
+  if (!ignoreStr) return null;
+  let cleanStr = ignoreStr.replace(/^\s*|\s*$/g, "");
+  if (/^\/.+\/$/.test(cleanStr)) {
+    cleanStr = cleanStr.replace(/(^\/)|(\/$)/g, "");
+    return new RegExp(cleanStr, "");
+  } else {
+    return new RegExp(cleanStr, "");
+  }
+}
+
+// src/parser.ts
+function dirToJson(dirPath, ignoreRegex, onlyFolder) {
+  let stats;
+  try {
+    stats = fs.lstatSync(dirPath);
+  } catch (e) {
+    return null;
+  }
+  if (stats.isDirectory()) {
+    let dir = fs.readdirSync(dirPath);
+    if (ignoreRegex) {
+      dir = dir.filter((val) => {
+        return !ignoreRegex.test(val);
+      });
+    }
+    const children = dir.filter((child) => {
+      const childPath = path.join(dirPath, child);
+      try {
+        const childStats = fs.lstatSync(childPath);
+        return onlyFolder ? childStats.isDirectory() : true;
+      } catch {
+        return false;
+      }
+    }).map((child) => {
+      return dirToJson(path.join(dirPath, child), ignoreRegex, onlyFolder);
+    }).filter((c) => c !== null);
+    const dirName = path.basename(dirPath);
+    const structure = {};
+    structure[dirName] = sortDir(children);
+    return structure;
+  } else {
+    return path.basename(dirPath);
+  }
+}
+
+// src/drawer.ts
+var characters = {
+  border: "\u2502   ",
+  contain: "\u251C\u2500\u2500 ",
+  last: "\u2514\u2500\u2500 "
+};
+var outputString = "";
+function resetOutput() {
+  outputString = "";
+}
+function drawDirTree(name, children, prefix = "", isLast = true, isRoot = false) {
+  const { border, contain, last } = characters;
+  const branch = isRoot ? "" : isLast ? last : contain;
+  outputString += (outputString ? "\n" : "") + prefix + branch + name;
+  if (Array.isArray(children)) {
+    const newPrefix = isRoot ? "" : prefix + (isLast ? "    " : border);
+    children.forEach((child, idx) => {
+      const childIsLast = idx === children.length - 1;
+      if (typeof child === "string") {
+        outputString += "\n" + newPrefix + (childIsLast ? last : contain) + child;
+      } else {
+        const keys = Object.keys(child);
+        if (keys.length > 0) {
+          const subName = keys[0];
+          const subChildren = child[subName];
+          drawDirTree(subName, subChildren, newPrefix, childIsLast, false);
+        }
+      }
+    });
+  }
+}
+function generateTreeString(structure) {
+  resetOutput();
+  if (typeof structure === "string") {
+    return structure;
+  }
+  const rootName = Object.keys(structure)[0];
+  if (rootName) {
+    const children = structure[rootName];
+    drawDirTree(rootName, children, "", true, true);
+  }
+  return outputString;
+}
+
+// src/index.ts
+import path2 from "path";
+function tree(options) {
+  const ignoreRegex = parseIgnoreOption(options.ignore);
+  const targetPath = path2.resolve(options.directory);
+  const structure = dirToJson(targetPath, ignoreRegex, options.onlyFolder);
+  if (!structure) {
+    return null;
+  }
+  return generateTreeString(structure);
+}
+
+// src/cli.ts
+var pkgPath = path3.join(__dirname, "../package.json");
+var version = "0.0.0";
+try {
+  const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+  version = pkg.version;
+} catch {
+}
+program.version(version).argument("[directory]", "Directory to generate structure tree").option("-d, --directory <dir>", "Specify a directory (alternative to positional argument)").option("-i, --ignore [ig]", "You can ignore specific directory name").option("-e, --export [epath]", "export into file").option("-f, --only-folder", "output folder only").action((dirArg, options) => {
+  const targetDir = dirArg || options.directory || process.cwd();
+  const output = tree({
+    directory: targetDir,
+    ignore: options.ignore,
+    onlyFolder: options.onlyFolder
+  });
+  if (!output) {
+    console.error(`Error: Could not read directory "${targetDir}"`);
+    process.exit(1);
+  }
+  console.log(output);
+  if (options.export) {
+    fs2.writeFile(options.export, output, (err) => {
+      if (err) throw err;
+      console.log("\n\nThe result has been saved into " + options.export);
+    });
+  }
+});
+program.parse(process.argv);
+//# sourceMappingURL=cli.mjs.map

package/dist/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli.ts","../src/parser.ts","../src/utils.ts","../src/drawer.ts","../src/index.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { program } from 'commander';\nimport fs from 'fs';\nimport path from 'path';\nimport { tree } from './index';\n\n// We need to read package.json version. \n// In TS/ESM, import assertions are the way, or reading file sync.\n// For simplicity and compatibility, we'll read it.\nconst pkgPath = path.join(__dirname, '../package.json');\nlet version = '0.0.0';\ntry {\n    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));\n    version = pkg.version;\n} catch {\n    // ignore\n}\n\nprogram\n  .version(version)\n  .argument('[directory]', 'Directory to generate structure tree')\n  .option('-d, --directory <dir>', 'Specify a directory (alternative to positional argument)')\n  .option('-i, --ignore [ig]', 'You can ignore specific directory name')\n  .option('-e, --export [epath]', 'export into file')\n  .option('-f, --only-folder', 'output folder only')\n  .action((dirArg, options) => {\n    const targetDir = dirArg || options.directory || process.cwd();\n\n    const output = tree({\n      directory: targetDir,\n      ignore: options.ignore,\n      onlyFolder: options.onlyFolder,\n    });\n\n    if (!output) {\n      console.error(`Error: Could not read directory \"${targetDir}\"`);\n      process.exit(1);\n    }\n\n    // Output to console\n    console.log(output);\n\n    // Export to file if requested\n    if (options.export) {\n      fs.writeFile(options.export, output, (err) => {\n        if (err) throw err;\n        console.log('\\n\\nThe result has been saved into ' + options.export);\n      });\n    }\n  });\n\nprogram.parse(process.argv);\n","import fs from 'fs';\nimport path from 'path';\nimport { sortDir } from './utils';\n\nexport type TreeStructure = { [key: string]: (string | TreeStructure)[] } | string;\n\n/**\n * Recursively scans a directory and returns a JSON-like structure.\n * @param dirPath - The path to scan.\n * @param ignoreRegex - The regex to filter file/folder names.\n * @param onlyFolder - If true, only include directories.\n */\nexport function dirToJson(\n  dirPath: string,\n  ignoreRegex: RegExp | null,\n  onlyFolder?: boolean\n): TreeStructure | null {\n  let stats: fs.Stats;\n  try {\n    stats = fs.lstatSync(dirPath);\n  } catch (e) {\n    return null;\n  }\n\n  if (stats.isDirectory()) {\n    let dir = fs.readdirSync(dirPath);\n\n    if (ignoreRegex) {\n      dir = dir.filter((val) => {\n        return !ignoreRegex.test(val);\n      });\n    }\n\n    // Map children to their structure\n    const children = dir\n      .filter((child) => {\n        const childPath = path.join(dirPath, child);\n        try {\n            const childStats = fs.lstatSync(childPath);\n            return onlyFolder ? childStats.isDirectory() : true;\n        } catch {\n            return false;\n        }\n      })\n      .map((child) => {\n        return dirToJson(path.join(dirPath, child), ignoreRegex, onlyFolder);\n      })\n      .filter((c): c is TreeStructure => c !== null); // Filter out nulls\n\n    const dirName = path.basename(dirPath);\n    const structure: TreeStructure = {};\n    // @ts-expect-error - sortDir returns (string|object)[], compatible with TreeStructure's array\n    structure[dirName] = sortDir(children);\n    return structure;\n  } else {\n    return path.basename(dirPath);\n  }\n}\n","/**\n * Sorts directory contents so that files come before folders.\n * Objects (directories) are put at the end.\n */\nexport function sortDir(arr: (string | object)[]): (string | object)[] {\n  let i = arr.length - 1;\n  while (i >= 0) {\n    if (typeof arr[i] === 'object') {\n      const obj = arr.splice(i, 1);\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      arr.push(obj[0]!);\n    }\n    i--;\n  }\n  return arr;\n}\n\n/**\n * Parses the ignore argument string into a RegExp object.\n * @param ignoreStr - The string passed via CLI (e.g. \"node_modules|dist\")\n */\nexport function parseIgnoreOption(ignoreStr?: string): RegExp | null {\n  if (!ignoreStr) return null;\n\n  let cleanStr = ignoreStr.replace(/^\\s*|\\s*$/g, '');\n\n  // Check if it's already a regex format like /node_modules/\n  if (/^\\/.+\\/$/.test(cleanStr)) {\n    cleanStr = cleanStr.replace(/(^\\/)|(\\/$)/g, '');\n    return new RegExp(cleanStr, '');\n  } else {\n    // Treat simple strings with pipes as regex OR, without escaping special chars excessively\n    // to allow user provided regex-like strings (e.g. \"node_modules|.git\")\n    return new RegExp(cleanStr, '');\n  }\n}\n","import { type TreeStructure } from './parser';\n\nconst characters = {\n  border: '│   ',\n  contain: '├── ',\n  last: '└── ',\n};\n\nlet outputString = '';\n\nfunction resetOutput() {\n  outputString = '';\n}\n\n/**\n * Recursive function to draw the tree structure.\n */\nfunction drawDirTree(\n  name: string,\n  children: (string | TreeStructure)[],\n  prefix = '',\n  isLast = true,\n  isRoot = false\n) {\n  const { border, contain, last } = characters;\n  const branch = isRoot ? '' : isLast ? last : contain;\n\n  outputString += (outputString ? '\\n' : '') + prefix + branch + name;\n\n  if (Array.isArray(children)) {\n    const newPrefix = isRoot ? '' : prefix + (isLast ? '    ' : border);\n    children.forEach((child, idx) => {\n      const childIsLast = idx === children.length - 1;\n      if (typeof child === 'string') {\n        outputString += '\\n' + newPrefix + (childIsLast ? last : contain) + child;\n      } else {\n        // child is { subName: [subChildren] }\n        const keys = Object.keys(child);\n        if (keys.length > 0) {\n          const subName = keys[0] as string;\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          const subChildren = (child as any)[subName];\n          drawDirTree(subName, subChildren, newPrefix, childIsLast, false);\n        }\n      }\n    });\n  }\n}\n\n/**\n * Main entry point to generate the tree string.\n */\nexport function generateTreeString(structure: TreeStructure): string {\n  resetOutput();\n\n  // If it's just a single file (string), return it\n  if (typeof structure === 'string') {\n    return structure;\n  }\n\n  // It's a directory object { rootName: [...] }\n  const rootName = Object.keys(structure)[0];\n  if (rootName) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const children = (structure as any)[rootName];\n      drawDirTree(rootName, children, '', true, true);\n  }\n\n  return outputString;\n}\n","// Public API exports\nexport * from './parser';\nexport * from './drawer';\nexport * from './utils';\n\n// Re-export main functionality for programmatic use\nimport path from 'path';\nimport { dirToJson } from './parser';\nimport { generateTreeString } from './drawer';\nimport { parseIgnoreOption } from './utils';\n\nexport type TreeOptions = {\n  directory: string;\n  ignore?: string;\n  onlyFolder?: boolean;\n};\n\n/**\n * Generates an ASCII tree string for the given directory.\n */\nexport function tree(options: TreeOptions): string | null {\n  const ignoreRegex = parseIgnoreOption(options.ignore);\n  const targetPath = path.resolve(options.directory);\n\n  const structure = dirToJson(targetPath, ignoreRegex, options.onlyFolder);\n\n  if (!structure) {\n    return null;\n  }\n\n  return generateTreeString(structure);\n}\n"],"mappings":"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","names":["fs","path","path","path","path","fs"]}

package/dist/index.cjs

@@ -0,0 +1,166 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  dirToJson: () => dirToJson,
+  generateTreeString: () => generateTreeString,
+  parseIgnoreOption: () => parseIgnoreOption,
+  sortDir: () => sortDir,
+  tree: () => tree
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/parser.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+
+// src/utils.ts
+function sortDir(arr) {
+  let i = arr.length - 1;
+  while (i >= 0) {
+    if (typeof arr[i] === "object") {
+      const obj = arr.splice(i, 1);
+      arr.push(obj[0]);
+    }
+    i--;
+  }
+  return arr;
+}
+function parseIgnoreOption(ignoreStr) {
+  if (!ignoreStr) return null;
+  let cleanStr = ignoreStr.replace(/^\s*|\s*$/g, "");
+  if (/^\/.+\/$/.test(cleanStr)) {
+    cleanStr = cleanStr.replace(/(^\/)|(\/$)/g, "");
+    return new RegExp(cleanStr, "");
+  } else {
+    return new RegExp(cleanStr, "");
+  }
+}
+
+// src/parser.ts
+function dirToJson(dirPath, ignoreRegex, onlyFolder) {
+  let stats;
+  try {
+    stats = import_fs.default.lstatSync(dirPath);
+  } catch (e) {
+    return null;
+  }
+  if (stats.isDirectory()) {
+    let dir = import_fs.default.readdirSync(dirPath);
+    if (ignoreRegex) {
+      dir = dir.filter((val) => {
+        return !ignoreRegex.test(val);
+      });
+    }
+    const children = dir.filter((child) => {
+      const childPath = import_path.default.join(dirPath, child);
+      try {
+        const childStats = import_fs.default.lstatSync(childPath);
+        return onlyFolder ? childStats.isDirectory() : true;
+      } catch {
+        return false;
+      }
+    }).map((child) => {
+      return dirToJson(import_path.default.join(dirPath, child), ignoreRegex, onlyFolder);
+    }).filter((c) => c !== null);
+    const dirName = import_path.default.basename(dirPath);
+    const structure = {};
+    structure[dirName] = sortDir(children);
+    return structure;
+  } else {
+    return import_path.default.basename(dirPath);
+  }
+}
+
+// src/drawer.ts
+var characters = {
+  border: "\u2502   ",
+  contain: "\u251C\u2500\u2500 ",
+  last: "\u2514\u2500\u2500 "
+};
+var outputString = "";
+function resetOutput() {
+  outputString = "";
+}
+function drawDirTree(name, children, prefix = "", isLast = true, isRoot = false) {
+  const { border, contain, last } = characters;
+  const branch = isRoot ? "" : isLast ? last : contain;
+  outputString += (outputString ? "\n" : "") + prefix + branch + name;
+  if (Array.isArray(children)) {
+    const newPrefix = isRoot ? "" : prefix + (isLast ? "    " : border);
+    children.forEach((child, idx) => {
+      const childIsLast = idx === children.length - 1;
+      if (typeof child === "string") {
+        outputString += "\n" + newPrefix + (childIsLast ? last : contain) + child;
+      } else {
+        const keys = Object.keys(child);
+        if (keys.length > 0) {
+          const subName = keys[0];
+          const subChildren = child[subName];
+          drawDirTree(subName, subChildren, newPrefix, childIsLast, false);
+        }
+      }
+    });
+  }
+}
+function generateTreeString(structure) {
+  resetOutput();
+  if (typeof structure === "string") {
+    return structure;
+  }
+  const rootName = Object.keys(structure)[0];
+  if (rootName) {
+    const children = structure[rootName];
+    drawDirTree(rootName, children, "", true, true);
+  }
+  return outputString;
+}
+
+// src/index.ts
+var import_path2 = __toESM(require("path"));
+function tree(options) {
+  const ignoreRegex = parseIgnoreOption(options.ignore);
+  const targetPath = import_path2.default.resolve(options.directory);
+  const structure = dirToJson(targetPath, ignoreRegex, options.onlyFolder);
+  if (!structure) {
+    return null;
+  }
+  return generateTreeString(structure);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dirToJson,
+  generateTreeString,
+  parseIgnoreOption,
+  sortDir,
+  tree
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/parser.ts","../src/utils.ts","../src/drawer.ts"],"sourcesContent":["// Public API exports\nexport * from './parser';\nexport * from './drawer';\nexport * from './utils';\n\n// Re-export main functionality for programmatic use\nimport path from 'path';\nimport { dirToJson } from './parser';\nimport { generateTreeString } from './drawer';\nimport { parseIgnoreOption } from './utils';\n\nexport type TreeOptions = {\n  directory: string;\n  ignore?: string;\n  onlyFolder?: boolean;\n};\n\n/**\n * Generates an ASCII tree string for the given directory.\n */\nexport function tree(options: TreeOptions): string | null {\n  const ignoreRegex = parseIgnoreOption(options.ignore);\n  const targetPath = path.resolve(options.directory);\n\n  const structure = dirToJson(targetPath, ignoreRegex, options.onlyFolder);\n\n  if (!structure) {\n    return null;\n  }\n\n  return generateTreeString(structure);\n}\n","import fs from 'fs';\nimport path from 'path';\nimport { sortDir } from './utils';\n\nexport type TreeStructure = { [key: string]: (string | TreeStructure)[] } | string;\n\n/**\n * Recursively scans a directory and returns a JSON-like structure.\n * @param dirPath - The path to scan.\n * @param ignoreRegex - The regex to filter file/folder names.\n * @param onlyFolder - If true, only include directories.\n */\nexport function dirToJson(\n  dirPath: string,\n  ignoreRegex: RegExp | null,\n  onlyFolder?: boolean\n): TreeStructure | null {\n  let stats: fs.Stats;\n  try {\n    stats = fs.lstatSync(dirPath);\n  } catch (e) {\n    return null;\n  }\n\n  if (stats.isDirectory()) {\n    let dir = fs.readdirSync(dirPath);\n\n    if (ignoreRegex) {\n      dir = dir.filter((val) => {\n        return !ignoreRegex.test(val);\n      });\n    }\n\n    // Map children to their structure\n    const children = dir\n      .filter((child) => {\n        const childPath = path.join(dirPath, child);\n        try {\n            const childStats = fs.lstatSync(childPath);\n            return onlyFolder ? childStats.isDirectory() : true;\n        } catch {\n            return false;\n        }\n      })\n      .map((child) => {\n        return dirToJson(path.join(dirPath, child), ignoreRegex, onlyFolder);\n      })\n      .filter((c): c is TreeStructure => c !== null); // Filter out nulls\n\n    const dirName = path.basename(dirPath);\n    const structure: TreeStructure = {};\n    // @ts-expect-error - sortDir returns (string|object)[], compatible with TreeStructure's array\n    structure[dirName] = sortDir(children);\n    return structure;\n  } else {\n    return path.basename(dirPath);\n  }\n}\n","/**\n * Sorts directory contents so that files come before folders.\n * Objects (directories) are put at the end.\n */\nexport function sortDir(arr: (string | object)[]): (string | object)[] {\n  let i = arr.length - 1;\n  while (i >= 0) {\n    if (typeof arr[i] === 'object') {\n      const obj = arr.splice(i, 1);\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      arr.push(obj[0]!);\n    }\n    i--;\n  }\n  return arr;\n}\n\n/**\n * Parses the ignore argument string into a RegExp object.\n * @param ignoreStr - The string passed via CLI (e.g. \"node_modules|dist\")\n */\nexport function parseIgnoreOption(ignoreStr?: string): RegExp | null {\n  if (!ignoreStr) return null;\n\n  let cleanStr = ignoreStr.replace(/^\\s*|\\s*$/g, '');\n\n  // Check if it's already a regex format like /node_modules/\n  if (/^\\/.+\\/$/.test(cleanStr)) {\n    cleanStr = cleanStr.replace(/(^\\/)|(\\/$)/g, '');\n    return new RegExp(cleanStr, '');\n  } else {\n    // Treat simple strings with pipes as regex OR, without escaping special chars excessively\n    // to allow user provided regex-like strings (e.g. \"node_modules|.git\")\n    return new RegExp(cleanStr, '');\n  }\n}\n","import { type TreeStructure } from './parser';\n\nconst characters = {\n  border: '│   ',\n  contain: '├── ',\n  last: '└── ',\n};\n\nlet outputString = '';\n\nfunction resetOutput() {\n  outputString = '';\n}\n\n/**\n * Recursive function to draw the tree structure.\n */\nfunction drawDirTree(\n  name: string,\n  children: (string | TreeStructure)[],\n  prefix = '',\n  isLast = true,\n  isRoot = false\n) {\n  const { border, contain, last } = characters;\n  const branch = isRoot ? '' : isLast ? last : contain;\n\n  outputString += (outputString ? '\\n' : '') + prefix + branch + name;\n\n  if (Array.isArray(children)) {\n    const newPrefix = isRoot ? '' : prefix + (isLast ? '    ' : border);\n    children.forEach((child, idx) => {\n      const childIsLast = idx === children.length - 1;\n      if (typeof child === 'string') {\n        outputString += '\\n' + newPrefix + (childIsLast ? last : contain) + child;\n      } else {\n        // child is { subName: [subChildren] }\n        const keys = Object.keys(child);\n        if (keys.length > 0) {\n          const subName = keys[0] as string;\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          const subChildren = (child as any)[subName];\n          drawDirTree(subName, subChildren, newPrefix, childIsLast, false);\n        }\n      }\n    });\n  }\n}\n\n/**\n * Main entry point to generate the tree string.\n */\nexport function generateTreeString(structure: TreeStructure): string {\n  resetOutput();\n\n  // If it's just a single file (string), return it\n  if (typeof structure === 'string') {\n    return structure;\n  }\n\n  // It's a directory object { rootName: [...] }\n  const rootName = Object.keys(structure)[0];\n  if (rootName) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const children = (structure as any)[rootName];\n      drawDirTree(rootName, children, '', true, true);\n  }\n\n  return outputString;\n}\n"],"mappings":"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","names":["fs","path","import_path","path"]}

package/dist/index.d.mts

@@ -0,0 +1,38 @@
+type TreeStructure = {
+    [key: string]: (string | TreeStructure)[];
+} | string;
+/**
+ * Recursively scans a directory and returns a JSON-like structure.
+ * @param dirPath - The path to scan.
+ * @param ignoreRegex - The regex to filter file/folder names.
+ * @param onlyFolder - If true, only include directories.
+ */
+declare function dirToJson(dirPath: string, ignoreRegex: RegExp | null, onlyFolder?: boolean): TreeStructure | null;
+
+/**
+ * Main entry point to generate the tree string.
+ */
+declare function generateTreeString(structure: TreeStructure): string;
+
+/**
+ * Sorts directory contents so that files come before folders.
+ * Objects (directories) are put at the end.
+ */
+declare function sortDir(arr: (string | object)[]): (string | object)[];
+/**
+ * Parses the ignore argument string into a RegExp object.
+ * @param ignoreStr - The string passed via CLI (e.g. "node_modules|dist")
+ */
+declare function parseIgnoreOption(ignoreStr?: string): RegExp | null;
+
+type TreeOptions = {
+    directory: string;
+    ignore?: string;
+    onlyFolder?: boolean;
+};
+/**
+ * Generates an ASCII tree string for the given directory.
+ */
+declare function tree(options: TreeOptions): string | null;
+
+export { type TreeOptions, type TreeStructure, dirToJson, generateTreeString, parseIgnoreOption, sortDir, tree };

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+type TreeStructure = {
+    [key: string]: (string | TreeStructure)[];
+} | string;
+/**
+ * Recursively scans a directory and returns a JSON-like structure.
+ * @param dirPath - The path to scan.
+ * @param ignoreRegex - The regex to filter file/folder names.
+ * @param onlyFolder - If true, only include directories.
+ */
+declare function dirToJson(dirPath: string, ignoreRegex: RegExp | null, onlyFolder?: boolean): TreeStructure | null;
+
+/**
+ * Main entry point to generate the tree string.
+ */
+declare function generateTreeString(structure: TreeStructure): string;
+
+/**
+ * Sorts directory contents so that files come before folders.
+ * Objects (directories) are put at the end.
+ */
+declare function sortDir(arr: (string | object)[]): (string | object)[];
+/**
+ * Parses the ignore argument string into a RegExp object.
+ * @param ignoreStr - The string passed via CLI (e.g. "node_modules|dist")
+ */
+declare function parseIgnoreOption(ignoreStr?: string): RegExp | null;
+
+type TreeOptions = {
+    directory: string;
+    ignore?: string;
+    onlyFolder?: boolean;
+};
+/**
+ * Generates an ASCII tree string for the given directory.
+ */
+declare function tree(options: TreeOptions): string | null;
+
+export { type TreeOptions, type TreeStructure, dirToJson, generateTreeString, parseIgnoreOption, sortDir, tree };

package/dist/index.mjs

@@ -0,0 +1,125 @@
+// src/parser.ts
+import fs from "fs";
+import path from "path";
+
+// src/utils.ts
+function sortDir(arr) {
+  let i = arr.length - 1;
+  while (i >= 0) {
+    if (typeof arr[i] === "object") {
+      const obj = arr.splice(i, 1);
+      arr.push(obj[0]);
+    }
+    i--;
+  }
+  return arr;
+}
+function parseIgnoreOption(ignoreStr) {
+  if (!ignoreStr) return null;
+  let cleanStr = ignoreStr.replace(/^\s*|\s*$/g, "");
+  if (/^\/.+\/$/.test(cleanStr)) {
+    cleanStr = cleanStr.replace(/(^\/)|(\/$)/g, "");
+    return new RegExp(cleanStr, "");
+  } else {
+    return new RegExp(cleanStr, "");
+  }
+}
+
+// src/parser.ts
+function dirToJson(dirPath, ignoreRegex, onlyFolder) {
+  let stats;
+  try {
+    stats = fs.lstatSync(dirPath);
+  } catch (e) {
+    return null;
+  }
+  if (stats.isDirectory()) {
+    let dir = fs.readdirSync(dirPath);
+    if (ignoreRegex) {
+      dir = dir.filter((val) => {
+        return !ignoreRegex.test(val);
+      });
+    }
+    const children = dir.filter((child) => {
+      const childPath = path.join(dirPath, child);
+      try {
+        const childStats = fs.lstatSync(childPath);
+        return onlyFolder ? childStats.isDirectory() : true;
+      } catch {
+        return false;
+      }
+    }).map((child) => {
+      return dirToJson(path.join(dirPath, child), ignoreRegex, onlyFolder);
+    }).filter((c) => c !== null);
+    const dirName = path.basename(dirPath);
+    const structure = {};
+    structure[dirName] = sortDir(children);
+    return structure;
+  } else {
+    return path.basename(dirPath);
+  }
+}
+
+// src/drawer.ts
+var characters = {
+  border: "\u2502   ",
+  contain: "\u251C\u2500\u2500 ",
+  last: "\u2514\u2500\u2500 "
+};
+var outputString = "";
+function resetOutput() {
+  outputString = "";
+}
+function drawDirTree(name, children, prefix = "", isLast = true, isRoot = false) {
+  const { border, contain, last } = characters;
+  const branch = isRoot ? "" : isLast ? last : contain;
+  outputString += (outputString ? "\n" : "") + prefix + branch + name;
+  if (Array.isArray(children)) {
+    const newPrefix = isRoot ? "" : prefix + (isLast ? "    " : border);
+    children.forEach((child, idx) => {
+      const childIsLast = idx === children.length - 1;
+      if (typeof child === "string") {
+        outputString += "\n" + newPrefix + (childIsLast ? last : contain) + child;
+      } else {
+        const keys = Object.keys(child);
+        if (keys.length > 0) {
+          const subName = keys[0];
+          const subChildren = child[subName];
+          drawDirTree(subName, subChildren, newPrefix, childIsLast, false);
+        }
+      }
+    });
+  }
+}
+function generateTreeString(structure) {
+  resetOutput();
+  if (typeof structure === "string") {
+    return structure;
+  }
+  const rootName = Object.keys(structure)[0];
+  if (rootName) {
+    const children = structure[rootName];
+    drawDirTree(rootName, children, "", true, true);
+  }
+  return outputString;
+}
+
+// src/index.ts
+import path2 from "path";
+function tree(options) {
+  const ignoreRegex = parseIgnoreOption(options.ignore);
+  const targetPath = path2.resolve(options.directory);
+  const structure = dirToJson(targetPath, ignoreRegex, options.onlyFolder);
+  if (!structure) {
+    return null;
+  }
+  return generateTreeString(structure);
+}
+export {
+  dirToJson,
+  generateTreeString,
+  parseIgnoreOption,
+  sortDir,
+  tree
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parser.ts","../src/utils.ts","../src/drawer.ts","../src/index.ts"],"sourcesContent":["import fs from 'fs';\nimport path from 'path';\nimport { sortDir } from './utils';\n\nexport type TreeStructure = { [key: string]: (string | TreeStructure)[] } | string;\n\n/**\n * Recursively scans a directory and returns a JSON-like structure.\n * @param dirPath - The path to scan.\n * @param ignoreRegex - The regex to filter file/folder names.\n * @param onlyFolder - If true, only include directories.\n */\nexport function dirToJson(\n  dirPath: string,\n  ignoreRegex: RegExp | null,\n  onlyFolder?: boolean\n): TreeStructure | null {\n  let stats: fs.Stats;\n  try {\n    stats = fs.lstatSync(dirPath);\n  } catch (e) {\n    return null;\n  }\n\n  if (stats.isDirectory()) {\n    let dir = fs.readdirSync(dirPath);\n\n    if (ignoreRegex) {\n      dir = dir.filter((val) => {\n        return !ignoreRegex.test(val);\n      });\n    }\n\n    // Map children to their structure\n    const children = dir\n      .filter((child) => {\n        const childPath = path.join(dirPath, child);\n        try {\n            const childStats = fs.lstatSync(childPath);\n            return onlyFolder ? childStats.isDirectory() : true;\n        } catch {\n            return false;\n        }\n      })\n      .map((child) => {\n        return dirToJson(path.join(dirPath, child), ignoreRegex, onlyFolder);\n      })\n      .filter((c): c is TreeStructure => c !== null); // Filter out nulls\n\n    const dirName = path.basename(dirPath);\n    const structure: TreeStructure = {};\n    // @ts-expect-error - sortDir returns (string|object)[], compatible with TreeStructure's array\n    structure[dirName] = sortDir(children);\n    return structure;\n  } else {\n    return path.basename(dirPath);\n  }\n}\n","/**\n * Sorts directory contents so that files come before folders.\n * Objects (directories) are put at the end.\n */\nexport function sortDir(arr: (string | object)[]): (string | object)[] {\n  let i = arr.length - 1;\n  while (i >= 0) {\n    if (typeof arr[i] === 'object') {\n      const obj = arr.splice(i, 1);\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      arr.push(obj[0]!);\n    }\n    i--;\n  }\n  return arr;\n}\n\n/**\n * Parses the ignore argument string into a RegExp object.\n * @param ignoreStr - The string passed via CLI (e.g. \"node_modules|dist\")\n */\nexport function parseIgnoreOption(ignoreStr?: string): RegExp | null {\n  if (!ignoreStr) return null;\n\n  let cleanStr = ignoreStr.replace(/^\\s*|\\s*$/g, '');\n\n  // Check if it's already a regex format like /node_modules/\n  if (/^\\/.+\\/$/.test(cleanStr)) {\n    cleanStr = cleanStr.replace(/(^\\/)|(\\/$)/g, '');\n    return new RegExp(cleanStr, '');\n  } else {\n    // Treat simple strings with pipes as regex OR, without escaping special chars excessively\n    // to allow user provided regex-like strings (e.g. \"node_modules|.git\")\n    return new RegExp(cleanStr, '');\n  }\n}\n","import { type TreeStructure } from './parser';\n\nconst characters = {\n  border: '│   ',\n  contain: '├── ',\n  last: '└── ',\n};\n\nlet outputString = '';\n\nfunction resetOutput() {\n  outputString = '';\n}\n\n/**\n * Recursive function to draw the tree structure.\n */\nfunction drawDirTree(\n  name: string,\n  children: (string | TreeStructure)[],\n  prefix = '',\n  isLast = true,\n  isRoot = false\n) {\n  const { border, contain, last } = characters;\n  const branch = isRoot ? '' : isLast ? last : contain;\n\n  outputString += (outputString ? '\\n' : '') + prefix + branch + name;\n\n  if (Array.isArray(children)) {\n    const newPrefix = isRoot ? '' : prefix + (isLast ? '    ' : border);\n    children.forEach((child, idx) => {\n      const childIsLast = idx === children.length - 1;\n      if (typeof child === 'string') {\n        outputString += '\\n' + newPrefix + (childIsLast ? last : contain) + child;\n      } else {\n        // child is { subName: [subChildren] }\n        const keys = Object.keys(child);\n        if (keys.length > 0) {\n          const subName = keys[0] as string;\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          const subChildren = (child as any)[subName];\n          drawDirTree(subName, subChildren, newPrefix, childIsLast, false);\n        }\n      }\n    });\n  }\n}\n\n/**\n * Main entry point to generate the tree string.\n */\nexport function generateTreeString(structure: TreeStructure): string {\n  resetOutput();\n\n  // If it's just a single file (string), return it\n  if (typeof structure === 'string') {\n    return structure;\n  }\n\n  // It's a directory object { rootName: [...] }\n  const rootName = Object.keys(structure)[0];\n  if (rootName) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const children = (structure as any)[rootName];\n      drawDirTree(rootName, children, '', true, true);\n  }\n\n  return outputString;\n}\n","// Public API exports\nexport * from './parser';\nexport * from './drawer';\nexport * from './utils';\n\n// Re-export main functionality for programmatic use\nimport path from 'path';\nimport { dirToJson } from './parser';\nimport { generateTreeString } from './drawer';\nimport { parseIgnoreOption } from './utils';\n\nexport type TreeOptions = {\n  directory: string;\n  ignore?: string;\n  onlyFolder?: boolean;\n};\n\n/**\n * Generates an ASCII tree string for the given directory.\n */\nexport function tree(options: TreeOptions): string | null {\n  const ignoreRegex = parseIgnoreOption(options.ignore);\n  const targetPath = path.resolve(options.directory);\n\n  const structure = dirToJson(targetPath, ignoreRegex, options.onlyFolder);\n\n  if (!structure) {\n    return null;\n  }\n\n  return generateTreeString(structure);\n}\n"],"mappings":"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","names":["path","path"]}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@skapxd/tree",
+  "version": "1.0.1",
+  "description": "A directory structure tree generator for CLI",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "tree": "./dist/cli.cjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run -c vitest.unit.config.ts",
+    "test:ui": "vitest --ui -c vitest.unit.config.ts",
+    "test:coverage": "vitest run --coverage -c vitest.unit.config.ts",
+    "typecheck": "tsc --noEmit",
+    "start": "node dist/cli.cjs"
+  },
+  "keywords": [
+    "directory",
+    "tree",
+    "cli",
+    "ascii",
+    "structure"
+  ],
+  "author": "skapxd",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "14.0.2"
+  },
+  "devDependencies": {
+    "@types/commander": "2.12.5",
+    "@types/node": "25.0.10",
+    "@vitest/coverage-v8": "4.0.17",
+    "@vitest/ui": "4.0.17",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "vitest": "4.0.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/skapxd/tree"
+  }
+}