Add treeJson() API and improve public interface

- Split tree() (text) and treeJson() (structured JSON) into separate
  exports, removing the json option from Options
- Change tree from default export to named export
- Rename JsonNode to TreeJsonEntry with discriminated union type
  (directories have required contents, files do not)
- Update README with new API docs and type definition
- CLI wraps treeJson() result in array for Linux tree -J compatibility

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: yangshun

README.md

@@ -91,20 +91,55 @@ Options:
 
 ## Node.js API
 
+### `tree(path, options?)`
+
+Returns the tree as a formatted string.
+
 ```js
-import tree from 'tree-node-cli';
+import { tree } from 'tree-node-cli';
+
+const string = tree('path/to/dir', {
+  allFiles: true,
+  exclude: [/node_modules/, /lcov/],
+  maxDepth: 4,
+});
 
-const string = tree('path/to/dir', options);
+console.log(string);
 ```
 
+### `treeJson(path, options?)`
+
+Returns the tree as a structured `TreeJsonEntry` object (or `null` if the path is excluded).
+
+```ts
+// Discriminated union — `contents` only exists on directories
+type TreeJsonEntry =
+  | { type: 'directory'; name: string; contents: TreeJsonEntry[];
+      size?: number; mode?: string; time?: string }
+  | { type: 'file'; name: string;
+      size?: number; mode?: string; time?: string }
+// size: present when `sizes: true`
+// mode: present when `permissions: true`
+// time: present when `date: true`
+```
+
+```js
+import { treeJson } from 'tree-node-cli';
+
+const result = treeJson('path/to/dir', { sizes: true });
+console.log(result);
+// { type: 'directory', name: 'dir', size: 4096, contents: [...] }
+```
+
+### Options
+
 `options` is a configuration object with the following fields:
 
 | Field           | Default                    | Type       | Description                                                                                                                           |
 | --------------- | -------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------- |
 | `allFiles`      | `false`                    | `boolean`  | All files are printed. By default, tree does not print hidden files (those beginning with a dot).                                     |
 | `date`          | `false`                    | `boolean`  | Show last modification time for each entry.                                                                                           |
 | `dirsFirst`     | `false`                    | `boolean`  | List directories before files.                                                                                                        |
-| `json`          | `false`                    | `boolean`  | Output the tree as a JSON structure.                                                                                                  |
 | `fullPath`      | `false`                    | `boolean`  | Print the full path prefix for each file.                                                                                             |
 | `noIndent`      | `false`                    | `boolean`  | Print entries without tree indentation lines.                                                                                         |
 | `permissions`   | `false`                    | `boolean`  | Show file type and permissions (e.g. `[drwxr-xr-x]`).                                                                                |
@@ -121,18 +156,6 @@ const string = tree('path/to/dir', options);
 | `sortBy`        | `'name'`                   | `string`   | Sort the output. Options: `'name'`, `'version'`, `'mtime'`, `'ctime'`, `'size'`.                                                     |
 | `unsorted`      | `false`                    | `boolean`  | Do not sort. List files in directory order.                                                                                            |
 
-```js
-import tree from 'tree-node-cli';
-
-const string = tree('path/to/dir', {
-  allFiles: true,
-  exclude: [/node_modules/, /lcov/],
-  maxDepth: 4,
-});
-
-console.log(string);
-```
-
 **Note:** To exclude the contents of a directory while retaining the directory itself, use a trailing slash with the `-I` option (e.g., `-I "node_modules/"`). For the Node.js API, provide a regex matching the directory contents (e.g., `/node_modules\//`). See [#33](https://github.com/yangshun/tree-node-cli/issues/33) for more details.
 
 ## License

src/cli.ts

@@ -2,7 +2,7 @@
 
 import { createRequire } from 'module';
 import cac from 'cac';
-import tree, { type Options } from './index';
+import { type Options, tree, treeJson } from './index';
 
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
@@ -83,7 +83,6 @@ const options: Options = {
   ...((process.argv.includes('-i') || process.argv.includes('--no-indent')) && {
     noIndent: true,
   }),
-  ...(opts.json != null && { json: opts.json as boolean }),
   ...(opts.permissions != null && { permissions: opts.permissions as boolean }),
   ...(opts.prune != null && { prune: opts.prune as boolean }),
   ...(opts.quote != null && { quote: opts.quote as boolean }),
@@ -103,5 +102,9 @@ const options: Options = {
   ...(opts.unsorted != null && { unsorted: opts.unsorted as boolean }),
 };
 
-const output = tree(path, options);
-console.log(output);
+if (opts.json) {
+  const jsonOutput = treeJson(path, options);
+  console.log(JSON.stringify([jsonOutput], null, 2));
+} else {
+  console.log(tree(path, options));
+}

src/formats/json.ts

@@ -1,41 +1,51 @@
 import type { RequiredOptions, TreeNode } from '../index';
 import { formatPermissions } from '../utils/format-permissions';
 
-export interface JsonNode {
-  type: 'directory' | 'file';
+interface TreeJsonEntryBase {
   name: string;
   size?: number;
   mode?: string;
   time?: string;
-  contents?: JsonNode[];
 }
 
+interface TreeJsonDirectoryEntry extends TreeJsonEntryBase {
+  type: 'directory';
+  contents: TreeJsonEntry[];
+}
+
+interface TreeJsonFileEntry extends TreeJsonEntryBase {
+  type: 'file';
+}
+
+export type TreeJsonEntry = TreeJsonDirectoryEntry | TreeJsonFileEntry;
+
 export function formatAsJson(
   node: TreeNode,
   options: RequiredOptions,
-): JsonNode {
-  const jsonNode: JsonNode = {
-    type: node.isDirectory ? 'directory' : 'file',
+): TreeJsonEntry {
+  const base: TreeJsonEntryBase = {
     name: node.name,
   };
 
   if (options.sizes) {
-    jsonNode.size = node.size;
+    base.size = node.size;
   }
 
   if (options.permissions) {
-    jsonNode.mode = formatPermissions(node.mode, node.isDirectory);
+    base.mode = formatPermissions(node.mode, node.isDirectory);
   }
 
   if (options.date) {
-    jsonNode.time = `${node.mtime.toLocaleDateString('en-CA')} ${node.mtime.toLocaleTimeString('en-GB')}`;
+    base.time = `${node.mtime.toLocaleDateString('en-CA')} ${node.mtime.toLocaleTimeString('en-GB')}`;
   }
 
   if (node.isDirectory) {
-    jsonNode.contents = node.children.map((child) =>
-      formatAsJson(child, options),
-    );
+    return {
+      ...base,
+      type: 'directory',
+      contents: node.children.map((child) => formatAsJson(child, options)),
+    };
   }
 
-  return jsonNode;
+  return { ...base, type: 'file' };
 }