feat(output): add multiple output formats support 📁

- Add JSON format output for structured data
- Add Markdown format output for documentation
- Add GenerateOptions interface for format configuration
- Add TreeNode interface for structured output
- Add Generator class for format handling
- Update API to support format parameter
- Update documentation with format examples
- Update installation command to JSR format

Author: NeaByteLab

README.md

@@ -6,6 +6,7 @@ A file tree generator for Deno. Generate beautiful directory trees instantly fro
 
 - [Installation](#installation)
 - [Quick Start](#quick-start)
+  - [Multiple Output Formats](#multiple-output-formats)
 - [Configuration](#configuration)
   - [Tree Options](#tree-options)
   - [Performance Settings](#performance-settings)
@@ -18,7 +19,9 @@ A file tree generator for Deno. Generate beautiful directory trees instantly fro
 - [API Reference](#api-reference)
   - [Main API](#main-api)
   - [Configuration Options](#configuration-options)
+  - [Generate Options](#generate-options)
   - [File Metadata](#file-metadata)
+  - [Tree Node Structure](#tree-node-structure)
 - [Troubleshooting](#troubleshooting)
   - [Common Issues](#common-issues)
   - [Debug Mode](#debug-mode)
@@ -28,7 +31,7 @@ A file tree generator for Deno. Generate beautiful directory trees instantly fro
 ## Installation
 
 ```bash
-deno install @neabyte/deno-tree
+deno add jsr:@neabyte/deno-tree
 ```
 
 ## Quick Start
@@ -66,6 +69,84 @@ console.log(result)
 └── README.md
 ```
 
+### Multiple Output Formats
+
+```ts
+import tree from '@neabyte/deno-tree'
+
+await tree.init('/path/to/directory', {
+  ignoreDirs: ['node_modules', '.git', 'dist'],
+  maxFiles: 1000,
+  showHidden: false,
+  maxDepth: 3
+})
+
+// Tree format (default)
+const treeOutput = await tree.generate('/path/to/directory')
+console.log(treeOutput)
+
+// JSON format
+const jsonOutput = await tree.generate('/path/to/directory', { format: 'json' })
+console.log(jsonOutput)
+
+// Markdown format
+const markdownOutput = await tree.generate('/path/to/directory', { format: 'markdown' })
+console.log(markdownOutput)
+```
+
+**Format Examples:**
+
+**Tree Format:**
+
+```
+.
+├── src/
+│   ├── components/
+│   │   ├── Button.tsx
+│   │   └── Modal.tsx
+│   └── index.ts
+├── deno.json
+└── README.md
+```
+
+**JSON Format:**
+
+```json
+{
+  "name": "project",
+  "type": "directory",
+  "path": "/path/to/project",
+  "children": [
+    {
+      "name": "src",
+      "type": "directory",
+      "path": "/path/to/project/src",
+      "children": [
+        {
+          "name": "Button.tsx",
+          "type": "file",
+          "path": "/path/to/project/src/Button.tsx",
+          "size": 1024,
+          "extension": "tsx"
+        }
+      ]
+    }
+  ]
+}
+```
+
+**Markdown Format:**
+
+```
+project/
+  - src/
+    - Button.tsx
+    - Modal.tsx
+    - index.ts
+  - deno.json
+  - README.md
+```
+
 ## Configuration
 
 ### Tree Options
@@ -79,6 +160,15 @@ interface TreeOptions {
 }
 ```
 
+### Generate Options
+
+```ts
+interface GenerateOptions {
+  format?: 'tree' | 'json' | 'markdown' // Output format (default: 'tree')
+  includeStats?: boolean // Include file statistics (default: false)
+}
+```
+
 ### Performance Settings
 
 ```ts
@@ -134,6 +224,7 @@ const projectA = await tree.generate('/workspace/project-a')
 const projectB = await tree.generate('/workspace/project-b')
 const projectC = await tree.generate('/workspace/project-c')
 
+// Log the trees
 console.log('Project A Tree:', projectA)
 console.log('Project B Tree:', projectB)
 console.log('Project C Tree:', projectC)
@@ -202,13 +293,13 @@ console.log('Project B:', treeB)
 
 ### Main API
 
-| Method       | Description                            | Parameters                            | Returns           |
-| ------------ | -------------------------------------- | ------------------------------------- | ----------------- |
-| `clear()`    | Clear all stored file metadata         | None                                  | `void`            |
-| `generate()` | Generate formatted tree string         | `rootPath: string`                    | `Promise<string>` |
-| `init()`     | Scan directory and store file metadata | `path: string, options?: TreeOptions` | `Promise<void>`   |
-| `remove()`   | Remove file/directory from tree        | `path: string`                        | `Promise<void>`   |
-| `set()`      | Add single file to tree metadata       | `path: string`                        | `Promise<void>`   |
+| Method       | Description                            | Parameters                                    | Returns           |
+| ------------ | -------------------------------------- | --------------------------------------------- | ----------------- |
+| `clear()`    | Clear all stored file metadata         | None                                          | `void`            |
+| `generate()` | Generate formatted tree string         | `rootPath: string, options?: GenerateOptions` | `Promise<string>` |
+| `init()`     | Scan directory and store file metadata | `path: string, options?: TreeOptions`         | `Promise<void>`   |
+| `remove()`   | Remove file/directory from tree        | `path: string`                                | `Promise<void>`   |
+| `set()`      | Add single file to tree metadata       | `path: string`                                | `Promise<void>`   |
 
 ### Configuration Options
 
@@ -219,6 +310,13 @@ console.log('Project B:', treeB)
 | `showHidden` | boolean  | ❌       | Show hidden files/directories | `false`                    |
 | `maxDepth`   | number   | ❌       | Maximum directory depth       | `3`                        |
 
+### Generate Options
+
+| Property       | Type    | Required | Description             | Example                |
+| -------------- | ------- | -------- | ----------------------- | ---------------------- |
+| `format`       | string  | ❌       | Output format           | `'json'`, `'markdown'` |
+| `includeStats` | boolean | ❌       | Include file statistics | `true`                 |
+
 ### File Metadata
 
 ```ts
@@ -233,6 +331,20 @@ interface FileMetadata {
 }
 ```
 
+### Tree Node Structure
+
+```ts
+interface TreeNode {
+  name: string // Node name
+  type: 'file' | 'directory' // Node type
+  path: string // Absolute path
+  size?: number // File size in bytes
+  modified?: Date // Last modification date
+  extension?: string // File extension
+  children?: TreeNode[] // Child nodes
+}
+```
+
 ## Troubleshooting
 
 ### Common Issues
@@ -260,14 +372,21 @@ interface FileMetadata {
 ```ts
 import tree from '@neabyte/deno-tree'
 
-// Debug file storage
+// Debug file storage and generation
 await tree.init('/path/to/project', { maxFiles: 100 })
-console.log('Files stored:', tree.files.size)
 
 // Debug specific path generation
 const result = await tree.generate('/path/to/project/src')
 console.log('Generated tree length:', result.length)
 console.log('Tree output:', result)
+
+// Debug JSON format
+const jsonResult = await tree.generate('/path/to/project', { format: 'json' })
+console.log('JSON output length:', jsonResult.length)
+
+// Debug markdown format
+const markdownResult = await tree.generate('/path/to/project', { format: 'markdown' })
+console.log('Markdown output length:', markdownResult.length)
 ```
 
 ## Contributing

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@neabyte/deno-tree",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "license": "MIT",
   "exports": "./src/index.ts",

src/Generator.ts

@@ -0,0 +1,157 @@
+import type { FileMetadata, TreeNode } from '@app/Types.ts'
+import { formatDirectory } from '@app/Utils.ts'
+
+/**
+ * Tree output generator for different formats.
+ * @description Handles generation of trees in various output formats.
+ */
+export class Generator {
+  /**
+   * Generates JSON format output.
+   * @param rootPath - Root directory path
+   * @param files - Map of scanned files
+   * @returns JSON string
+   */
+  async generateJsonFormat(rootPath: string, files: Map<string, FileMetadata>): Promise<string> {
+    try {
+      const treeNode = await this.buildTreeNode(rootPath, files)
+      return JSON.stringify(treeNode, null, 2)
+    } catch {
+      return '{}'
+    }
+  }
+
+  /**
+   * Generates Markdown format output.
+   * @param rootPath - Root directory path
+   * @param files - Map of scanned files
+   * @returns Markdown string
+   */
+  async generateMarkdownFormat(
+    rootPath: string,
+    files: Map<string, FileMetadata>
+  ): Promise<string> {
+    try {
+      const treeNode = await this.buildTreeNode(rootPath, files)
+      return this.treeToMarkdown(treeNode)
+    } catch {
+      return ''
+    }
+  }
+
+  /**
+   * Generates tree format output (original ASCII tree).
+   * @param rootPath - Root directory path
+   * @param files - Map of scanned files
+   * @param showHidden - Whether to show hidden files
+   * @returns ASCII tree string
+   */
+  async generateTreeFormat(
+    rootPath: string,
+    files: Map<string, FileMetadata>,
+    showHidden: boolean
+  ): Promise<string> {
+    try {
+      const allFiles = Array.from(files.values())
+      const absoluteRootPath = await Deno.realPath(rootPath)
+      const rootFiles = allFiles.filter(f => f.path.startsWith(`${absoluteRootPath}/`))
+      if (rootFiles.length === 0) {
+        return ''
+      }
+      const rootName = rootPath.split('/').pop() || rootPath
+      return formatDirectory(rootName, absoluteRootPath, 0, allFiles, showHidden)
+    } catch {
+      return ''
+    }
+  }
+
+  /**
+   * Builds node structure recursively.
+   * @param name - Node name
+   * @param path - Node path
+   * @param files - All files in the tree
+   * @returns TreeNode structure
+   */
+  private buildNodeStructure(name: string, path: string, files: FileMetadata[]): TreeNode {
+    const node: TreeNode = {
+      name,
+      type: 'directory',
+      path,
+      children: []
+    }
+    const children = files.filter(f => f.parent === path)
+    const subdirs = new Set<string>()
+    for (const file of children) {
+      if (file.type === 'file') {
+        const fileNode: TreeNode = {
+          name: file.name,
+          type: 'file',
+          path: file.path
+        }
+        if (file.size !== undefined) {
+          fileNode.size = file.size
+        }
+        if (file.modified !== undefined) {
+          fileNode.modified = file.modified
+        }
+        if (file.extension !== undefined) {
+          fileNode.extension = file.extension
+        }
+        if (node.children) {
+          node.children.push(fileNode)
+        }
+      } else if (file.type === 'directory') {
+        subdirs.add(file.path)
+      }
+    }
+    for (const subdirPath of subdirs) {
+      const subdirName = subdirPath.split('/').pop() || ''
+      const subdirFiles = files.filter(f => f.path.startsWith(`${subdirPath}/`))
+      const subdirNode = this.buildNodeStructure(subdirName, subdirPath, subdirFiles)
+      if (node.children) {
+        node.children.push(subdirNode)
+      }
+    }
+    return node
+  }
+
+  /**
+   * Builds a TreeNode structure from scanned files.
+   * @param rootPath - Root directory path
+   * @param files - Map of scanned files
+   * @returns TreeNode structure
+   */
+  private async buildTreeNode(
+    rootPath: string,
+    files: Map<string, FileMetadata>
+  ): Promise<TreeNode> {
+    const allFiles = Array.from(files.values())
+    const absoluteRootPath = await Deno.realPath(rootPath)
+    const rootFiles = allFiles.filter(f => f.path.startsWith(`${absoluteRootPath}/`))
+    const rootName = rootPath.split('/').pop() || rootPath
+    return this.buildNodeStructure(rootName, absoluteRootPath, rootFiles)
+  }
+
+  /**
+   * Converts TreeNode to Markdown format.
+   * @param node - TreeNode to convert
+   * @param depth - Current depth level
+   * @returns Markdown string
+   */
+  private treeToMarkdown(node: TreeNode, depth = 0): string {
+    const indent = '  '.repeat(depth)
+    const prefix = depth === 0 ? '' : '- '
+    let result = `${indent}${prefix}${node.name}/\n`
+    if (node.children) {
+      for (const child of node.children) {
+        if (child.type === 'directory') {
+          result += this.treeToMarkdown(child, depth + 1)
+        } else {
+          const childIndent = '  '.repeat(depth + 1)
+          result += `${childIndent}- ${child.name}\n`
+        }
+      }
+    }
+    return result
+  }
+}