@crashbytes/dendro 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to dendro will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-10-13
+
+### Added
+- Initial release of dendro 🌳
+- Beautiful directory tree visualization with Unicode box-drawing characters
+- Smart file type icons for 30+ file types
+- CLI with flexible options (depth control, filtering, etc.)
+- Programmatic API for Node.js integration
+- Statistics display (file and directory counts)
+- Smart default exclusions (node_modules, .git, etc.)
+- Regex-based pattern exclusion
+- Hidden file support with `-a` flag
+- Full path display option
+- Plain text mode (no icons)
+- Comprehensive documentation and examples
+
+### Features
+- 📁 Directory visualization
+- 🎨 File type icons
+- ⚡ Fast directory traversal
+- 🎯 Pattern-based filtering
+- 📊 Built-in statistics
+- 🔧 Both CLI and API
+
+[1.0.0]: https://github.com/CrashBytes/dendron/releases/tag/v1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 CrashBytes
+
+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/QUICKSTART.md

@@ -0,0 +1,109 @@
+# Quick Start Guide - dendro 🌳
+
+## What is dendro?
+
+**dendro** (δένδρο) is Greek for "tree" - a beautiful CLI tool to visualize directory structures with file type icons.
+
+## Installation
+
+```bash
+cd ~/github/crashbytes-tree
+npm install
+```
+
+## Testing Methods
+
+### Method 1: Run the test suite
+```bash
+npm test
+```
+
+### Method 2: Run CLI directly (no installation)
+```bash
+# Test on current directory
+node bin/cli.js
+
+# Test on crashbytes blog
+node bin/cli.js ~/github/crashbytes
+
+# Test with depth limit
+node bin/cli.js ~/github/crashbytes -d 2
+
+# Show all options
+node bin/cli.js --help
+```
+
+### Method 3: Install globally (recommended)
+```bash
+npm link
+```
+
+Then use anywhere:
+```bash
+dendro
+dendro ~/github/crashbytes -d 3
+dendro . -a
+```
+
+### Method 4: Use with npx (after publishing)
+```bash
+npx @crashbytes/dendro
+```
+
+## Common Test Commands
+
+```bash
+# Show 2 levels of current directory
+node bin/cli.js -d 2
+
+# Show all files including hidden
+node bin/cli.js -a
+
+# Exclude patterns
+node bin/cli.js -e "test" "*.log"
+
+# Show without icons
+node bin/cli.js --no-icons
+
+# Show with full paths
+node bin/cli.js -p
+
+# Visualize the dendro project itself
+node bin/cli.js . -d 2
+```
+
+## Programmatic Usage
+
+Create a test file:
+
+```javascript
+// my-test.js
+const { buildTree, renderTree, getTreeStats } = require('@crashbytes/dendro');
+
+const tree = buildTree('.', { maxDepth: 2 });
+const output = renderTree(tree, { showIcons: true });
+console.log(output);
+
+const stats = getTreeStats(tree);
+console.log(`\n${stats.directories} dirs, ${stats.files} files`);
+```
+
+Run it:
+```bash
+node my-test.js
+```
+
+## Publishing to NPM
+
+When ready:
+```bash
+npm login
+npm publish
+```
+
+## Why "dendro"?
+
+- **δένδρο** (dendro) = Greek for "tree"
+- Short, memorable, professional
+- Used in science (dendrology, dendrochronology)
+- Perfect for visualizing tree structures!

package/README.md

@@ -0,0 +1,385 @@
+# dendro 🌳
+
+[![npm version](https://badge.fury.io/js/%40crashbytes%2Fdendro.svg)](https://www.npmjs.com/package/@crashbytes/dendro)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![GitHub issues](https://img.shields.io/github/issues/CrashBytes/dendron)](https://github.com/CrashBytes/dendron/issues)
+[![GitHub stars](https://img.shields.io/github/stars/CrashBytes/dendron)](https://github.com/CrashBytes/dendron/stargazers)
+
+**dendro** (δένδρο) - from the Greek word for "tree"
+
+A beautiful, fast directory tree visualization CLI with intuitive file type icons.
+
+🔗 **[GitHub Repository](https://github.com/CrashBytes/dendron)** | 📦 **[npm Package](https://www.npmjs.com/package/@crashbytes/dendro)**
+
+---
+
+## Why "dendro"?
+
+The name **dendro** comes from the Greek word **δένδρο** (pronounced "DEN-droh"), meaning "tree". It's:
+
+- **Memorable** - Short, unique, and easy to remember
+- **Meaningful** - Directly relates to tree structures and hierarchies
+- **Professional** - Used in scientific contexts (dendrology, dendrochronology)
+- **Global** - Recognizable across languages due to its Greek root
+- **Concise** - Just 6 letters, quick to type
+
+When you visualize directory structures, you're essentially mapping a tree—and that's exactly what dendro does, with style.
+
+---
+
+## Features
+
+- 🌳 Beautiful tree visualization with Unicode box-drawing characters
+- 🎨 **Smart file type icons** for instant visual recognition
+- ⚡ Lightning fast - optimized directory traversal
+- 🎯 Flexible filtering with regex pattern support
+- 📊 Built-in statistics (file counts, directory counts)
+- 🔧 Both CLI and programmatic API
+- 🎭 Smart defaults (auto-excludes node_modules, .git, etc.)
+
+## Installation
+
+### Via npm (Recommended)
+
+```bash
+npm install -g @crashbytes/dendro
+```
+
+### Via npx (No Installation)
+
+```bash
+npx @crashbytes/dendro
+```
+
+### From Source (GitHub)
+
+```bash
+git clone https://github.com/CrashBytes/dendron.git
+cd dendron
+npm install
+npm link
+```
+
+## Quick Start
+
+```bash
+# Visualize current directory
+dendro
+
+# Visualize specific directory
+dendro /path/to/project
+
+# Limit depth to 3 levels
+dendro ~/projects -d 3
+
+# Show all files including hidden
+dendro -a
+
+# Show help
+dendro --help
+```
+
+## Usage
+
+### Command Line Options
+
+```
+Usage: dendro [path] [options]
+
+Arguments:
+  path                       Directory path to display (default: ".")
+
+Options:
+  -V, --version              Output version number
+  -d, --max-depth <number>   Maximum depth to traverse
+  -a, --all                  Show hidden files and directories
+  --no-icons                 Disable file type icons
+  -p, --show-paths           Show full paths
+  -e, --exclude <patterns>   Patterns to exclude (regex)
+  --no-stats                 Hide statistics summary
+  -h, --help                 Display help
+```
+
+### Examples
+
+```bash
+# Show only 2 levels deep
+dendro -d 2
+
+# Show all files including hidden ones
+dendro -a
+
+# Exclude specific patterns (node_modules, test directories)
+dendro -e "node_modules" "test" "__pycache__"
+
+# Show full file paths
+dendro -p
+
+# Plain text output (no icons)
+dendro --no-icons
+
+# Combine options
+dendro ~/my-project -d 3 -a -e "*.log" "dist"
+```
+
+## File Type Icons
+
+dendro automatically detects and displays appropriate icons for common file types:
+
+| Icon | File Types |
+|------|-----------|
+| 📁 | Directories |
+| 📜 | JavaScript (.js, .jsx, .mjs, .cjs) |
+| 📘 | TypeScript (.ts, .tsx) |
+| 📋 | JSON (.json) |
+| 📝 | Markdown (.md, .mdx) |
+| 🎨 | Stylesheets (.css, .scss, .sass, .less) |
+| 🌐 | HTML (.html, .htm) |
+| 🖼️ | Images (.png, .jpg, .gif, .svg, .webp) |
+| 🎬 | Videos (.mp4, .avi, .mov, .mkv) |
+| 🎵 | Audio (.mp3, .wav, .ogg, .m4a) |
+| 📕 | PDFs (.pdf) |
+| 🗜️ | Archives (.zip, .tar, .gz, .rar, .7z) |
+| 🗄️ | Databases (.db, .sqlite, .sql) |
+| ⚙️ | Config files (.yaml, .yml, .toml, .ini) |
+| 🔒 | Lock files (package-lock.json, yarn.lock) |
+| 📦 | Git files (.gitignore, .gitattributes) |
+| 📄 | Other text files |
+
+## Programmatic API
+
+Use dendro in your Node.js projects:
+
+```javascript
+const { buildTree, renderTree, getTreeStats } = require('@crashbytes/dendro');
+
+// Build a tree structure
+const tree = buildTree('/path/to/directory', {
+  maxDepth: 3,
+  showHidden: false,
+  excludePatterns: [/node_modules/, /\.git/]
+});
+
+// Render as text
+const output = renderTree(tree, {
+  showIcons: true,
+  showPaths: false
+});
+
+console.log(output);
+
+// Get statistics
+const stats = getTreeStats(tree);
+console.log(`${stats.directories} directories, ${stats.files} files`);
+```
+
+### API Reference
+
+#### `buildTree(dirPath, options)`
+
+Builds a tree data structure from a directory.
+
+**Parameters:**
+- `dirPath` (string) - Path to directory
+- `options` (object)
+  - `maxDepth` (number) - Maximum depth to traverse (default: Infinity)
+  - `showHidden` (boolean) - Include hidden files (default: false)
+  - `excludePatterns` (RegExp[]) - Patterns to exclude (default: [])
+
+**Returns:** Tree object with structure:
+```javascript
+{
+  name: string,
+  type: 'file' | 'directory',
+  icon: string,
+  path: string,
+  children?: TreeNode[]
+}
+```
+
+#### `renderTree(tree, options)`
+
+Renders a tree structure as formatted text.
+
+**Parameters:**
+- `tree` (object) - Tree structure from buildTree
+- `options` (object)
+  - `showIcons` (boolean) - Display file type icons (default: true)
+  - `showPaths` (boolean) - Display full paths (default: false)
+  - `prefix` (string) - Internal use for recursion
+  - `isLast` (boolean) - Internal use for recursion
+
+**Returns:** Formatted string representation
+
+#### `getTreeStats(tree)`
+
+Calculates statistics for a tree.
+
+**Returns:** Object with `{ files: number, directories: number }`
+
+## Default Exclusions
+
+By default (without `-a` flag), dendro excludes:
+- Hidden files/directories (starting with `.`)
+- `node_modules`
+- `.git`
+- `.DS_Store`
+- `dist`
+- `build`
+- `coverage`
+
+Override with `-a` or use `-e` to add custom exclusions.
+
+## Advanced Usage
+
+### Custom Filtering
+
+```javascript
+const { buildTree, renderTree } = require('@crashbytes/dendro');
+
+// Build tree
+const tree = buildTree('.', { maxDepth: 3 });
+
+// Filter to show only JavaScript files
+function filterJS(node) {
+  if (node.type === 'file') {
+    return /\.(js|jsx|ts|tsx)$/.test(node.name) ? node : null;
+  }
+  
+  if (node.children) {
+    const filtered = node.children.map(filterJS).filter(Boolean);
+    return filtered.length > 0 ? { ...node, children: filtered } : null;
+  }
+  
+  return null;
+}
+
+const jsOnly = filterJS(tree);
+console.log(renderTree(jsOnly));
+```
+
+### Integration with Build Tools
+
+```javascript
+// In your build script
+const { buildTree, getTreeStats } = require('@crashbytes/dendro');
+
+const tree = buildTree('./dist');
+const stats = getTreeStats(tree);
+
+console.log(`Build output: ${stats.files} files in ${stats.directories} directories`);
+```
+
+## Examples
+
+See the [`/examples`](https://github.com/CrashBytes/dendron/tree/main/examples) directory for more usage examples:
+- `basic-usage.js` - Simple tree visualization
+- `advanced-usage.js` - Custom filtering and statistics
+
+## Contributing
+
+We welcome contributions! Here's how you can help:
+
+1. **Fork the repository** on [GitHub](https://github.com/CrashBytes/dendron)
+2. **Clone your fork**
+   ```bash
+   git clone https://github.com/YOUR-USERNAME/dendron.git
+   cd dendron
+   npm install
+   ```
+3. **Create a feature branch**
+   ```bash
+   git checkout -b feature/amazing-feature
+   ```
+4. **Make your changes** and test them
+   ```bash
+   npm test
+   node bin/cli.js
+   ```
+5. **Commit your changes**
+   ```bash
+   git commit -m "Add amazing feature"
+   ```
+6. **Push to your fork**
+   ```bash
+   git push origin feature/amazing-feature
+   ```
+7. **Open a Pull Request** on GitHub
+
+### Areas for Contribution
+
+- 🎨 Add more file type icons
+- ⚡ Performance optimizations
+- 📝 Documentation improvements
+- 🐛 Bug fixes
+- ✨ New features
+
+## Bug Reports & Feature Requests
+
+Found a bug or have a feature request? Please open an issue on [GitHub Issues](https://github.com/CrashBytes/dendron/issues).
+
+When reporting bugs, please include:
+- Your OS and Node.js version
+- Steps to reproduce
+- Expected vs actual behavior
+- Screenshots if applicable
+
+## Development
+
+### Running Tests
+
+```bash
+npm test
+```
+
+### Local Development
+
+```bash
+# Clone the repository
+git clone https://github.com/CrashBytes/dendron.git
+cd dendron
+
+# Install dependencies
+npm install
+
+# Link for local testing
+npm link
+
+# Make changes and test
+dendro ~/test-directory
+```
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/CrashBytes/dendron/blob/main/CHANGELOG.md) for version history.
+
+## License
+
+MIT License - see [LICENSE](https://github.com/CrashBytes/dendron/blob/main/LICENSE) file for details.
+
+## Author
+
+**CrashBytes**
+- Website: [crashbytes.com](https://crashbytes.com)
+- GitHub: [@CrashBytes](https://github.com/CrashBytes)
+- Twitter: [@crashbytes](https://twitter.com/crashbytes)
+
+## Acknowledgments
+
+Built with ❤️ for developers who love beautiful CLIs.
+
+Special thanks to all [contributors](https://github.com/CrashBytes/dendron/graphs/contributors) who help make dendro better!
+
+---
+
+## Support
+
+If you find dendro useful, please:
+- ⭐ Star the project on [GitHub](https://github.com/CrashBytes/dendron)
+- 🐦 Share it on social media
+- 📝 Write a blog post about it
+- 💬 Tell your developer friends
+
+---
+
+*dendro - Because every great project starts with understanding its structure* 🌳

package/bin/cb-tree.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const dirTree = require('../index');
+
+const args = process.argv.slice(2);
+const options = {
+  all: false,
+  depth: Infinity,
+  dirsOnly: false,
+  exclude: []
+};
+
+let targetPath = process.cwd();
+
+// Parse arguments
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  
+  if (arg === '-a' || arg === '--all') {
+    options.all = true;
+  } else if (arg === '-d' || arg === '--dirs-only') {
+    options.dirsOnly = true;
+  } else if (arg === '-L' || arg === '--level') {
+    options.depth = parseInt(args[++i]);
+  } else if (arg === '-I' || arg === '--exclude') {
+    options.exclude.push(args[++i]);
+  } else if (arg === '-h' || arg === '--help') {
+    showHelp();
+    process.exit(0);
+  } else if (!arg.startsWith('-')) {
+    targetPath = path.resolve(arg);
+  }
+}
+
+function showHelp() {
+  console.log(`
+crashbytes-tree - A beautiful directory tree with file type icons
+
+Usage: cb-tree [options] [path]
+
+Options:
+  -a, --all           Show hidden files (starting with .)
+  -d, --dirs-only     List directories only
+  -L, --level <n>     Maximum depth of directory tree
+  -I, --exclude <pattern>  Exclude files/directories matching pattern
+  -h, --help          Show this help message
+
+Examples:
+  cb-tree                    # Show tree of current directory
+  cb-tree /path/to/dir       # Show tree of specific directory
+  cb-tree -L 2               # Show tree with max depth of 2
+  cb-tree -a -L 3            # Show tree including hidden files, max depth 3
+  cb-tree -d                 # Show directories only
+  `);
+}
+
+try {
+  console.log(dirTree(targetPath, options));
+} catch (error) {
+  console.error(`Error: ${error.message}`);
+  process.exit(1);
+}

package/bin/cli.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const path = require('path');
+const { buildTree, renderTree, getTreeStats } = require('../index');
+
+const program = new Command();
+
+program
+  .name('dendro')
+  .description('Display directory tree structure with beautiful icons')
+  .version('1.0.0')
+  .argument('[path]', 'Directory path to display', '.')
+  .option('-d, --max-depth <number>', 'Maximum depth to traverse', parseInt)
+  .option('-a, --all', 'Show hidden files and directories', false)
+  .option('--no-icons', 'Disable file type icons')
+  .option('-p, --show-paths', 'Show full paths', false)
+  .option('-e, --exclude <patterns...>', 'Patterns to exclude (regex)')
+  .option('--no-stats', 'Hide statistics summary')
+  .action((dirPath, options) => {
+    try {
+      const fullPath = path.resolve(dirPath);
+      
+      console.log(chalk.bold.cyan(`\n🌳 Directory Tree: ${fullPath}\n`));
+      
+      // Build exclude patterns
+      const excludePatterns = options.exclude 
+        ? options.exclude.map(p => new RegExp(p))
+        : [];
+      
+      // Common excludes by default
+      if (!options.all) {
+        excludePatterns.push(
+          /^node_modules$/,
+          /^\.git$/,
+          /^\.DS_Store$/,
+          /^dist$/,
+          /^build$/,
+          /^coverage$/
+        );
+      }
+      
+      // Build the tree
+      const tree = buildTree(fullPath, {
+        maxDepth: options.maxDepth || Infinity,
+        showHidden: options.all,
+        excludePatterns
+      });
+      
+      if (!tree) {
+        console.log(chalk.red('Error: Could not read directory'));
+        process.exit(1);
+      }
+      
+      // Render the tree
+      const output = renderTree(tree, {
+        showIcons: options.icons,
+        showPaths: options.showPaths
+      });
+      
+      console.log(output);
+      
+      // Show statistics
+      if (options.stats) {
+        const stats = getTreeStats(tree);
+        console.log(chalk.dim(`\n${stats.directories} directories, ${stats.files} files`));
+      }
+      
+      console.log(); // Empty line at the end
+      
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/examples/advanced-usage.js

@@ -0,0 +1,59 @@
+const { buildTree, renderTree, getTreeStats } = require('../index');
+const chalk = require('chalk');
+
+// Advanced usage with custom options
+console.log(chalk.bold.cyan('Advanced Directory Tree Example\n'));
+
+const tree = buildTree('.', {
+  maxDepth: 3,
+  showHidden: true,
+  excludePatterns: [
+    /node_modules/,
+    /\.git/,
+    /dist/,
+    /coverage/,
+    /\.log$/
+  ]
+});
+
+// Render with custom options
+const output = renderTree(tree, {
+  showIcons: true,
+  showPaths: false
+});
+
+console.log(output);
+
+// Get and display statistics
+const stats = getTreeStats(tree);
+console.log(chalk.dim(`\n📊 Statistics:`));
+console.log(chalk.dim(`   Directories: ${stats.directories}`));
+console.log(chalk.dim(`   Files: ${stats.files}`));
+console.log(chalk.dim(`   Total items: ${stats.directories + stats.files}`));
+
+// Custom filtering example
+console.log(chalk.bold.yellow('\n\n🔍 JavaScript files only:\n'));
+
+function filterJavaScriptFiles(node) {
+  if (node.type === 'file') {
+    const ext = node.name.split('.').pop();
+    return ['js', 'jsx', 'ts', 'tsx'].includes(ext) ? node : null;
+  }
+  
+  if (node.children) {
+    const filteredChildren = node.children
+      .map(filterJavaScriptFiles)
+      .filter(Boolean);
+    
+    if (filteredChildren.length > 0) {
+      return { ...node, children: filteredChildren };
+    }
+  }
+  
+  return null;
+}
+
+const jsTree = filterJavaScriptFiles(tree);
+if (jsTree) {
+  console.log(renderTree(jsTree, { showIcons: true }));
+}

package/examples/basic-usage.js

@@ -0,0 +1,14 @@
+const { buildTree, renderTree } = require('../index');
+
+// Basic usage example
+const tree = buildTree('.', {
+  maxDepth: 2,
+  showHidden: false
+});
+
+const output = renderTree(tree, {
+  showIcons: true,
+  showPaths: false
+});
+
+console.log(output);

package/index.js

@@ -0,0 +1,296 @@
+const fs = require('fs');
+const path = require('path');
+
+// Icon mappings for different file types and directories
+const icons = {
+  // Directory
+  directory: '📁',
+  directoryOpen: '📂',
+  
+  // Common file types
+  javascript: '📜',
+  typescript: '📘',
+  json: '📋',
+  markdown: '📝',
+  text: '📄',
+  image: '🖼️',
+  video: '🎬',
+  audio: '🎵',
+  pdf: '📕',
+  zip: '🗜️',
+  executable: '⚙️',
+  config: '⚙️',
+  css: '🎨',
+  html: '🌐',
+  database: '🗄️',
+  lock: '🔒',
+  git: '📦',
+  
+  // Default
+  default: '📄'
+};
+
+// File extension to icon mapping
+const extensionMap = {
+  // JavaScript/TypeScript
+  '.js': icons.javascript,
+  '.jsx': icons.javascript,
+  '.ts': icons.typescript,
+  '.tsx': icons.typescript,
+  '.mjs': icons.javascript,
+  '.cjs': icons.javascript,
+  
+  // Data formats
+  '.json': icons.json,
+  '.yaml': icons.config,
+  '.yml': icons.config,
+  '.xml': icons.config,
+  '.toml': icons.config,
+  '.ini': icons.config,
+  
+  // Markdown/Documentation
+  '.md': icons.markdown,
+  '.mdx': icons.markdown,
+  '.txt': icons.text,
+  '.pdf': icons.pdf,
+  
+  // Web
+  '.html': icons.html,
+  '.htm': icons.html,
+  '.css': icons.css,
+  '.scss': icons.css,
+  '.sass': icons.css,
+  '.less': icons.css,
+  
+  // Images
+  '.png': icons.image,
+  '.jpg': icons.image,
+  '.jpeg': icons.image,
+  '.gif': icons.image,
+  '.svg': icons.image,
+  '.webp': icons.image,
+  '.ico': icons.image,
+  '.bmp': icons.image,
+  
+  // Video
+  '.mp4': icons.video,
+  '.avi': icons.video,
+  '.mov': icons.video,
+  '.mkv': icons.video,
+  '.webm': icons.video,
+  
+  // Audio
+  '.mp3': icons.audio,
+  '.wav': icons.audio,
+  '.ogg': icons.audio,
+  '.m4a': icons.audio,
+  '.flac': icons.audio,
+  
+  // Archives
+  '.zip': icons.zip,
+  '.tar': icons.zip,
+  '.gz': icons.zip,
+  '.rar': icons.zip,
+  '.7z': icons.zip,
+  
+  // Databases
+  '.db': icons.database,
+  '.sqlite': icons.database,
+  '.sql': icons.database,
+  
+  // Executables
+  '.exe': icons.executable,
+  '.sh': icons.executable,
+  '.bat': icons.executable,
+  '.cmd': icons.executable,
+  
+  // Lock files
+  '.lock': icons.lock,
+};
+
+// Special filename mappings
+const filenameMap = {
+  '.gitignore': icons.git,
+  '.gitattributes': icons.git,
+  '.gitmodules': icons.git,
+  'package.json': icons.json,
+  'package-lock.json': icons.lock,
+  'yarn.lock': icons.lock,
+  'pnpm-lock.yaml': icons.lock,
+  '.env': icons.config,
+  '.env.local': icons.config,
+  '.env.development': icons.config,
+  '.env.production': icons.config,
+  'Dockerfile': icons.config,
+  'docker-compose.yml': icons.config,
+  'README.md': icons.markdown,
+};
+
+/**
+ * Get the appropriate icon for a file or directory
+ */
+function getIcon(filename, isDirectory) {
+  if (isDirectory) {
+    return icons.directory;
+  }
+  
+  // Check special filenames first
+  if (filenameMap[filename]) {
+    return filenameMap[filename];
+  }
+  
+  // Check by extension
+  const ext = path.extname(filename).toLowerCase();
+  if (extensionMap[ext]) {
+    return extensionMap[ext];
+  }
+  
+  return icons.default;
+}
+
+/**
+ * Build directory tree structure
+ */
+function buildTree(dirPath, options = {}) {
+  const {
+    maxDepth = Infinity,
+    currentDepth = 0,
+    showHidden = false,
+    excludePatterns = []
+  } = options;
+  
+  if (currentDepth >= maxDepth) {
+    return null;
+  }
+  
+  try {
+    const stats = fs.statSync(dirPath);
+    const name = path.basename(dirPath);
+    
+    // Check if should exclude
+    if (!showHidden && name.startsWith('.')) {
+      return null;
+    }
+    
+    for (const pattern of excludePatterns) {
+      if (name.match(pattern)) {
+        return null;
+      }
+    }
+    
+    if (!stats.isDirectory()) {
+      return {
+        name,
+        type: 'file',
+        icon: getIcon(name, false),
+        path: dirPath
+      };
+    }
+    
+    // It's a directory
+    const children = [];
+    const entries = fs.readdirSync(dirPath);
+    
+    for (const entry of entries) {
+      const childPath = path.join(dirPath, entry);
+      const childTree = buildTree(childPath, {
+        ...options,
+        currentDepth: currentDepth + 1
+      });
+      
+      if (childTree) {
+        children.push(childTree);
+      }
+    }
+    
+    // Sort: directories first, then files, alphabetically
+    children.sort((a, b) => {
+      if (a.type !== b.type) {
+        return a.type === 'directory' ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+    
+    return {
+      name,
+      type: 'directory',
+      icon: getIcon(name, true),
+      path: dirPath,
+      children
+    };
+  } catch (error) {
+    console.error(`Error reading ${dirPath}:`, error.message);
+    return null;
+  }
+}
+
+/**
+ * Render the tree structure as text
+ */
+function renderTree(tree, options = {}) {
+  const {
+    prefix = '',
+    isLast = true,
+    showIcons = true,
+    showPaths = false
+  } = options;
+  
+  if (!tree) return '';
+  
+  const lines = [];
+  const connector = isLast ? '└── ' : '├── ';
+  const icon = showIcons ? `${tree.icon} ` : '';
+  const pathInfo = showPaths ? ` (${tree.path})` : '';
+  
+  lines.push(`${prefix}${connector}${icon}${tree.name}${pathInfo}`);
+  
+  if (tree.children && tree.children.length > 0) {
+    const newPrefix = prefix + (isLast ? '    ' : '│   ');
+    
+    tree.children.forEach((child, index) => {
+      const childIsLast = index === tree.children.length - 1;
+      lines.push(renderTree(child, {
+        ...options,
+        prefix: newPrefix,
+        isLast: childIsLast
+      }));
+    });
+  }
+  
+  return lines.join('\n');
+}
+
+/**
+ * Get statistics about the tree
+ */
+function getTreeStats(tree) {
+  if (!tree) {
+    return { files: 0, directories: 0 };
+  }
+  
+  let files = 0;
+  let directories = 0;
+  
+  if (tree.type === 'file') {
+    files = 1;
+  } else if (tree.type === 'directory') {
+    directories = 1;
+    if (tree.children) {
+      tree.children.forEach(child => {
+        const childStats = getTreeStats(child);
+        files += childStats.files;
+        directories += childStats.directories;
+      });
+    }
+  }
+  
+  return { files, directories };
+}
+
+module.exports = {
+  buildTree,
+  renderTree,
+  getTreeStats,
+  getIcon,
+  icons
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@crashbytes/dendro",
+  "version": "1.0.0",
+  "description": "A beautiful directory tree visualization CLI with file type icons - dendro (δένδρο) means 'tree' in Greek",
+  "main": "index.js",
+  "bin": {
+    "dendro": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "directory",
+    "tree",
+    "cli",
+    "file-tree",
+    "icons",
+    "visualization"
+  ],
+  "author": "CrashBytes",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "chalk": "^4.1.2"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/setup-and-test.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+echo "🌳 Setting up dendro package..."
+echo ""
+
+# Navigate to the package directory
+cd "$(dirname "$0")"
+
+echo "📦 Installing dependencies..."
+npm install
+
+echo ""
+echo "✅ Installation complete!"
+echo ""
+echo "🧪 Running tests..."
+echo ""
+node test.js
+
+echo ""
+echo "📋 Available commands:"
+echo ""
+echo "  1. Test locally:"
+echo "     node bin/cli.js"
+echo ""
+echo "  2. Test on a specific directory:"
+echo "     node bin/cli.js ~/github/crashbytes -d 2"
+echo ""
+echo "  3. Install globally (link):"
+echo "     npm link"
+echo "     Then run: dendro"
+echo ""
+echo "  4. Show help:"
+echo "     node bin/cli.js --help"
+echo ""
+echo "  5. Visualize the dendro project itself:"
+echo "     node bin/cli.js . -d 2"
+echo ""

package/test/test.js

@@ -0,0 +1,52 @@
+const { buildTree, treeToString, getIcon } = require('../index');
+const path = require('path');
+
+console.log('🧪 Running crashbytes-tree tests...\n');
+
+// Test 1: Icon recognition
+console.log('Test 1: Icon Recognition');
+console.log('------------------------');
+console.log('Folder icon:', getIcon('my-folder', true));
+console.log('JavaScript icon:', getIcon('app.js', false));
+console.log('JSON icon:', getIcon('package.json', false));
+console.log('Markdown icon:', getIcon('README.md', false));
+console.log('node_modules icon:', getIcon('node_modules', true));
+console.log('✅ Icon recognition test passed\n');
+
+// Test 2: Build tree structure
+console.log('Test 2: Build Tree Structure');
+console.log('------------------------');
+try {
+  const tree = buildTree(path.join(__dirname, '..'), {
+    maxDepth: 1,
+    showHidden: false,
+    ignorePatterns: ['node_modules', '.git']
+  });
+  
+  console.log('Root name:', tree.name);
+  console.log('Root type:', tree.type);
+  console.log('Root icon:', tree.icon);
+  console.log('Children count:', tree.children ? tree.children.length : 0);
+  console.log('✅ Build tree test passed\n');
+} catch (error) {
+  console.error('❌ Build tree test failed:', error.message);
+}
+
+// Test 3: Tree to string conversion
+console.log('Test 3: Tree to String');
+console.log('------------------------');
+try {
+  const tree = buildTree(path.join(__dirname, '..'), {
+    maxDepth: 2,
+    showHidden: false,
+    ignorePatterns: ['node_modules', '.git', 'test']
+  });
+  
+  const treeString = treeToString(tree);
+  console.log(treeString);
+  console.log('✅ Tree to string test passed\n');
+} catch (error) {
+  console.error('❌ Tree to string test failed:', error.message);
+}
+
+console.log('✅ All tests completed!');

package/test.js

@@ -0,0 +1,57 @@
+const { buildTree, renderTree, getTreeStats, getIcon } = require('./index');
+const path = require('path');
+
+console.log('Running tests for dendro...\n');
+
+// Test 1: Icon selection
+console.log('Test 1: Icon Selection');
+console.log('JavaScript file:', getIcon('app.js', false));
+console.log('TypeScript file:', getIcon('component.tsx', false));
+console.log('JSON file:', getIcon('package.json', false));
+console.log('Markdown file:', getIcon('README.md', false));
+console.log('Directory:', getIcon('src', true));
+console.log('✓ Icon selection test passed\n');
+
+// Test 2: Build tree for current directory (limited depth)
+console.log('Test 2: Build Tree');
+const testPath = path.resolve('.');
+const tree = buildTree(testPath, {
+  maxDepth: 2,
+  showHidden: false,
+  excludePatterns: [/node_modules/, /\.git/]
+});
+
+if (tree && tree.type === 'directory') {
+  console.log('✓ Tree built successfully');
+  console.log(`  Root: ${tree.name}`);
+  console.log(`  Children: ${tree.children ? tree.children.length : 0}`);
+} else {
+  console.log('✗ Tree build failed');
+}
+console.log();
+
+// Test 3: Render tree
+console.log('Test 3: Render Tree (first 2 levels)');
+const rendered = renderTree(tree, {
+  showIcons: true,
+  showPaths: false
+});
+
+if (rendered && rendered.length > 0) {
+  console.log('✓ Tree rendered successfully');
+  console.log('\nPreview:');
+  console.log(rendered.split('\n').slice(0, 15).join('\n'));
+  console.log('...');
+} else {
+  console.log('✗ Tree render failed');
+}
+console.log();
+
+// Test 4: Statistics
+console.log('Test 4: Statistics');
+const stats = getTreeStats(tree);
+console.log(`Files: ${stats.files}`);
+console.log(`Directories: ${stats.directories}`);
+console.log('✓ Statistics test passed\n');
+
+console.log('All tests completed!');