touch-all 1.1.10 → 1.2.1

package/README.md

@@ -1,13 +1,15 @@
 # touch-all
 
-CLI tool to create folder structures from markdown tree representations.
+CLI tool to create folder structures from Markdown tree representations.
 
-Pass a tree string — drawn with box-drawing characters or plain indentation — and `touch-all` creates every directory and file on disk.
+![](.media/terminal-sceen-cast.svg)
+
+It behaves like `mkdir -p` and `touch` combined, creating directories and files as needed. It can be used to quickly scaffold a project structure or generate placeholder files.
 
 ## Features
 
 - Accepts tree strings in **box-drawing** (`├──`, `└──`, `│`) or **indentation** (spaces) format
-- Trailing `/` marks a directory; no trailing `/` marks a file
+- Trailing slash `/` marks a directory; no trailing `/` marks a file
 - Inline comments stripped automatically (`# ...` and `// ...`)
 - `--dry-run` parses and validates without touching the file system
 - `--verbose` prints every created path
@@ -20,10 +22,10 @@ Pass a tree string — drawn with box-drawing characters or plain indentation
 npm install -g touch-all
 ```
 
-Or run without installing:
+or with `npx` without installing:
 
 ```bash
-npx touch-all "..."
+npx touch-all@latest "..."
 ```
 
 ## Usage
@@ -41,37 +43,37 @@ my-project/
 "
 ```
 
-### Specify target directory
+## Arguments
+
+- `--path` , `-p` – specifies target directory. By default, the current working directory is used. Can be an absolute path or a path relative to the current working directory.
 
 ```bash
-touch-all "..." --path ./my-project
-touch-all "..." -p ./my-project
+touch-all "..." --path=./my-project
+touch-all "..." -p ~/Documents/my-project
 ```
 
-### Dry run — parse and validate, no files created
+- `--dry-run` , `-n` – parses and validates the tree string without creating any files or directories. Useful for testing and debugging.
 
 ```bash
 touch-all "..." --dry-run
 touch-all "..." -n
 ```
 
-### Verbose output
+- `--verbose` , `-v` – prints every created path to the console. Useful for seeing exactly what will be created, especially with complex structures. It's an alias for `--log-level info`
 
 ```bash
 touch-all "..." --verbose
 touch-all "..." -v
 ```
 
-### Help
-
-```bash
-touch-all --help
-```
+- `--completions` – generates a completion script for a specific shell. Supported shells: `sh`, `bash`, `fish`, `zsh`.
+- `--log-level` – sets the minimum log level for a command. Supported levels: `all`, `trace`, `debug`, `info`, `warning`, `error`, `fatal`, `none`. The default log level is `warning`.
+- `--help` , `-h` – shows the help documentation for a command.
+- `--wizard` – starts wizard mode for a command, providing an interactive step-by-step interface.
+- `--version` – shows the version of the application.
 
 ## Tree Format
 
-Both formats produce identical results.
-
 ### Box-drawing characters
 
 ```
@@ -100,6 +102,8 @@ my-project/
   README.md
 ```
 
+Both formats produce identical results.
+
 ### Rules
 
 | Syntax            | Meaning                          |
@@ -108,8 +112,8 @@ my-project/
 | `name`            | file                             |
 | `dir/sub/`        | directory at an explicit subpath |
 | `dir/sub/file.ts` | file at an explicit subpath      |
-| `# comment`       | ignored (stripped)               |
-| `// comment`      | ignored (stripped)               |
+| `... # comment`   | ignored (stripped)               |
+| `... // comment`  | ignored (stripped)               |
 
 Items at the root level (no indentation / no parent) are created directly inside the target directory.
 
@@ -126,21 +130,28 @@ import {
   resolveProjectPathToBase,
   PathTraversalError,
   FsError,
-  cli,
 } from 'touch-all'
 import type { ParserResult, ParserResultLineItem } from 'touch-all'
 ```
 
 ### `parserFolderStructure(tree: string): ParserResult`
 
-Parses a tree string into a flat list of `{ path, isFile }` items. Pure function, no I/O.
+Parses a tree string into a flat list of `type ParserResult = { path: string, isFile: boolean }` items. Pure function, no I/O.
 
 ```ts
 const items = parserFolderStructure(`
   src/
     index.ts
 `)
-// [{ path: 'src', isFile: false }, { path: 'src/index.ts', isFile: true }]
+// [
+//    {
+//      path: 'src',
+//      isFile: false
+//     }, {
+//      path: 'src/index.ts',
+//      isFile: true
+//     }
+// ]
 ```
 
 ### `fileStructureCreator(items: ParserResult, basePath: string): Effect<void, FsError | PathTraversalError>`
@@ -151,15 +162,19 @@ Creates the parsed structure on disk under `basePath`. Returns an [Effect](https
 import { Effect } from 'effect'
 import { NodeContext, NodeRuntime } from '@effect/platform-node'
 
+const projectDirectory = '/absolute/target/path'
 const items = parserFolderStructure(tree)
 
-fileStructureCreator(items, '/absolute/target/path').pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain)
+fileStructureCreator(items, projectDirectory).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain)
 ```
 
 ### `resolveProjectPathToBase(projectPath: string, basePath: string): Effect<string, PathTraversalError>`
 
 Resolves `projectPath` relative to `basePath` and rejects any path that would escape `basePath` (path traversal protection).
 
+> [!CAUTION]
+> `projectPath` cannot traverse outside of `basePath`. If `projectPath` is absolute, it treated as relative to `basePath`. If `projectPath` is relative, it is resolved against `basePath`. In either case, if the resulting path is outside of `basePath`, a `PathTraversalError` is thrown.
+
 ### Error types
 
 | Class                | `_tag`                 | When thrown                                                     |

package/dist/lib/index.js

@@ -42,31 +42,31 @@ var resolveProjectPathToBase = (projectPath, basePath) => {
 };
 
 // src/fsGenerator.ts
-var fileStructureCreator = (items, basePath) => Effect2.gen(function* (_) {
-  yield* _(Effect2.logInfo(`Creating structure in: ${basePath}`));
+var fileStructureCreator = (items, basePath) => Effect2.gen(function* () {
+  yield* Effect2.logInfo(`Creating structure in: ${basePath}`);
   for (const item of items) {
-    const fullPath = yield* _(resolveProjectPathToBase(item.path, basePath));
+    const fullPath = yield* resolveProjectPathToBase(item.path, basePath);
     if (item.isFile) {
       const dir = path.dirname(fullPath);
-      yield* _(Effect2.try({
+      yield* Effect2.try({
         try: () => fs.mkdirSync(dir, { recursive: true }),
         catch: (error) => new FsError(`Failed to create directory ${dir}: ${String(error)}`)
-      }));
-      yield* _(Effect2.try({
+      });
+      yield* Effect2.try({
         try: () => fs.writeFileSync(fullPath, ""),
         catch: (error) => new FsError(`Failed to create file ${fullPath}: ${String(error)}`)
-      }));
-      yield* _(Effect2.logInfo(`  Created file:      ${item.path}`));
+      });
+      yield* Effect2.logInfo(`  Created file:      ${item.path}`);
     } else {
-      yield* _(Effect2.try({
+      yield* Effect2.try({
         try: () => fs.mkdirSync(fullPath, { recursive: true }),
         catch: (error) => new FsError(`Failed to create directory ${fullPath}: ${String(error)}`)
-      }));
-      yield* _(Effect2.logInfo(`  Created directory: ${item.path}`));
+      });
+      yield* Effect2.logInfo(`  Created directory: ${item.path}`);
     }
   }
-  yield* _(Effect2.logInfo(`
-✓ Structure created successfully!`));
+  yield* Effect2.logInfo(`
+✓ Structure created successfully!`);
 });
 // src/parser.ts
 var parserFolderStructure = (treeString) => {
@@ -80,13 +80,11 @@ var parserFolderStructure = (treeString) => {
     const [p01 = "", _comment01] = line.split("#");
     const [p02 = "", _comment02] = p01.split("//");
     const p03 = p02.replace(/[│├└─\t]/g, " ");
-    const cleanLine = p03.trim();
+    const cleanLine = p03.trim().replace(/^\.\//, "");
     if (!cleanLine)
       continue;
     if (cleanLine === "/")
       continue;
-    if (cleanLine.startsWith("./"))
-      continue;
     if (cleanLine.endsWith("../"))
       continue;
     const indent = countLeadingSpaces(p03);
@@ -114,62 +112,10 @@ function countLeadingSpaces(str) {
   const match = str.match(/^[\s]*/);
   return match ? match[0].length : 0;
 }
-// src/cli.ts
-import { Args, Command, Options } from "@effect/cli";
-import { Console, Effect as Effect3, Logger, LogLevel, Option } from "effect";
-import { createInterface } from "node:readline";
-var treeArg = Args.text({ name: "tree" }).pipe(Args.withDescription("Multiline string representing the directory tree structure"), Args.optional);
-var pathOption = Options.directory("path").pipe(Options.withAlias("p"), Options.withDefault("."), Options.withDescription("Target folder path (defaults to current directory)"));
-var dryRunOption = Options.boolean("dry-run").pipe(Options.withAlias("n"), Options.withDefault(false), Options.withDescription("Skip the top-level directory if there is only one"));
-var verboseOption = Options.boolean("verbose").pipe(Options.withAlias("v"), Options.withDefault(false), Options.withDescription("Log to console extra information about creating a directory tree"));
-var command = Command.make("touch-all", {
-  tree: treeArg,
-  path: pathOption,
-  dryRun: dryRunOption,
-  verbose: verboseOption
-}).pipe(Command.withDescription("Create directory structure from a tree representation"), Command.withHandler(({ tree, path: targetPath, dryRun = false, verbose }) => {
-  const readStdin = Effect3.tryPromise({
-    try: () => new Promise((resolve2) => {
-      const rl = createInterface({ input: process.stdin });
-      const lines = [];
-      rl.on("line", (line) => lines.push(line));
-      rl.on("close", () => resolve2(lines.join(`
-`)));
-    }),
-    catch: (e) => new Error(`Failed to read stdin: ${String(e)}`)
-  });
-  const program = Effect3.gen(function* (_) {
-    const treeString = Option.isSome(tree) ? tree.value : yield* _(readStdin);
-    if (dryRun) {
-      yield* _(Effect3.logInfo("Running in dry mode. No one file system node will be created."));
-    }
-    yield* _(Effect3.logInfo("Parsing tree structure..."));
-    const items = parserFolderStructure(treeString);
-    if (items.length === 0) {
-      yield* _(Console.error("No valid items found in the tree structure"));
-      yield* _(Console.error(items));
-      yield* _(Console.error(treeString));
-      return yield* _(Effect3.fail(new Error("Invalid tree structure")));
-    }
-    yield* _(Effect3.logInfo(`Found ${items.length} items to create`));
-    yield* _(Effect3.logInfo(`Found: 
-${items.map((i) => `${i.path} 
-`).join("")}`));
-    if (!dryRun) {
-      yield* _(fileStructureCreator(items, targetPath));
-    }
-  });
-  return verbose ? program.pipe(Logger.withMinimumLogLevel(LogLevel.Info)) : program;
-}));
-var cli = Command.run(command, {
-  name: "Touch All",
-  version: "0.0.1"
-});
 export {
   resolveProjectPathToBase,
   parserFolderStructure,
   fileStructureCreator,
-  cli,
   PathTraversalError,
   FsError
 };

package/dist/lib/{index.d.ts → src/index.d.ts}

@@ -3,4 +3,3 @@ export { resolveProjectPathToBase } from './fsNormalizator';
 export { PathTraversalError, FsError } from './_commonErrors';
 export type { ParserResult, ParserResultLineItem } from './_commonTypes';
 export { parserFolderStructure } from './parser';
-export { cli } from './cli';

package/dist/slim/touch-all.js

@@ -4,9 +4,9 @@ import { Effect as Effect4, Logger as Logger2, LogLevel as LogLevel2 } from "eff
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
 
 // src/cli.ts
+import { createInterface } from "node:readline";
 import { Args, Command, Options } from "@effect/cli";
 import { Console, Effect as Effect3, Logger, LogLevel, Option } from "effect";
-import { createInterface } from "node:readline";
 
 // src/parser.ts
 var parserFolderStructure = (treeString) => {
@@ -20,13 +20,11 @@ var parserFolderStructure = (treeString) => {
     const [p01 = "", _comment01] = line.split("#");
     const [p02 = "", _comment02] = p01.split("//");
     const p03 = p02.replace(/[│├└─\t]/g, " ");
-    const cleanLine = p03.trim();
+    const cleanLine = p03.trim().replace(/^\.\//, "");
     if (!cleanLine)
       continue;
     if (cleanLine === "/")
       continue;
-    if (cleanLine.startsWith("./"))
-      continue;
     if (cleanLine.endsWith("../"))
       continue;
     const indent = countLeadingSpaces(p03);
@@ -99,37 +97,103 @@ var resolveProjectPathToBase = (projectPath, basePath) => {
 };
 
 // src/fsGenerator.ts
-var fileStructureCreator = (items, basePath) => Effect2.gen(function* (_) {
-  yield* _(Effect2.logInfo(`Creating structure in: ${basePath}`));
+var fileStructureCreator = (items, basePath) => Effect2.gen(function* () {
+  yield* Effect2.logInfo(`Creating structure in: ${basePath}`);
   for (const item of items) {
-    const fullPath = yield* _(resolveProjectPathToBase(item.path, basePath));
+    const fullPath = yield* resolveProjectPathToBase(item.path, basePath);
     if (item.isFile) {
       const dir = path.dirname(fullPath);
-      yield* _(Effect2.try({
+      yield* Effect2.try({
         try: () => fs.mkdirSync(dir, { recursive: true }),
         catch: (error) => new FsError(`Failed to create directory ${dir}: ${String(error)}`)
-      }));
-      yield* _(Effect2.try({
+      });
+      yield* Effect2.try({
         try: () => fs.writeFileSync(fullPath, ""),
         catch: (error) => new FsError(`Failed to create file ${fullPath}: ${String(error)}`)
-      }));
-      yield* _(Effect2.logInfo(`  Created file:      ${item.path}`));
+      });
+      yield* Effect2.logInfo(`  Created file:      ${item.path}`);
     } else {
-      yield* _(Effect2.try({
+      yield* Effect2.try({
         try: () => fs.mkdirSync(fullPath, { recursive: true }),
         catch: (error) => new FsError(`Failed to create directory ${fullPath}: ${String(error)}`)
-      }));
-      yield* _(Effect2.logInfo(`  Created directory: ${item.path}`));
+      });
+      yield* Effect2.logInfo(`  Created directory: ${item.path}`);
     }
   }
-  yield* _(Effect2.logInfo(`
-✓ Structure created successfully!`));
+  yield* Effect2.logInfo(`
+✓ Structure created successfully!`);
 });
+// package.json
+var package_default = {
+  name: "touch-all",
+  version: "1.2.1",
+  description: "CLI tool to create folder structures from markdown tree representations",
+  keywords: [
+    "cli",
+    "folders",
+    "generator",
+    "markdown",
+    "structure"
+  ],
+  license: "GPL-3.0-or-later",
+  author: "Anton Huz <anton@ahuz.dev>",
+  repository: {
+    type: "git",
+    url: "https://github.com/anton-huz/touch-all"
+  },
+  bin: {
+    "touch-all": "dist/slim/touch-all.js"
+  },
+  files: [
+    "dist/slim",
+    "dist/lib"
+  ],
+  type: "module",
+  main: "dist/lib/index.js",
+  types: "dist/lib/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/lib/index.d.ts",
+      import: "./dist/lib/index.js"
+    }
+  },
+  publishConfig: {
+    access: "public",
+    provenance: true
+  },
+  scripts: {
+    build: "tsup --config .config/tsup.config.ts",
+    "check:lint": "oxlint . -c .config/.oxlintrc.json",
+    "check:format": "oxfmt . -c .config/.oxfmtrc.json --check",
+    "check:ts": "tsc --noEmit",
+    format: "oxfmt . -c .config/.oxfmtrc.json --write",
+    test: "vitest --config .config/vitest.config.ts run"
+  },
+  dependencies: {
+    "@effect/cli": "^0.75.0",
+    "@effect/platform-node": "^0.106.0",
+    effect: "^3.21.0"
+  },
+  devDependencies: {
+    "@total-typescript/tsconfig": "1.0.3",
+    "@types/bun": "1.3.11",
+    "@types/node": "25.5.0",
+    oxfmt: "0.41.0",
+    oxlint: "1.56.0",
+    tsup: "8.5.1",
+    typescript: "5.9.3",
+    vitest: "4.1.0"
+  },
+  engines: {
+    node: ">=18"
+  },
+  url: "https://github.com/anton-huz/touch-all"
+};
 
 // src/cli.ts
 var treeArg = Args.text({ name: "tree" }).pipe(Args.withDescription("Multiline string representing the directory tree structure"), Args.optional);
 var pathOption = Options.directory("path").pipe(Options.withAlias("p"), Options.withDefault("."), Options.withDescription("Target folder path (defaults to current directory)"));
-var dryRunOption = Options.boolean("dry-run").pipe(Options.withAlias("n"), Options.withDefault(false), Options.withDescription("Skip the top-level directory if there is only one"));
+var dryRunOption = Options.boolean("dry-run").pipe(Options.withAlias("n"), Options.withDefault(false), Options.withDescription("Parse and validate the tree without writing to the file system"));
 var verboseOption = Options.boolean("verbose").pipe(Options.withAlias("v"), Options.withDefault(false), Options.withDescription("Log to console extra information about creating a directory tree"));
 var command = Command.make("touch-all", {
   tree: treeArg,
@@ -137,42 +201,45 @@ var command = Command.make("touch-all", {
   dryRun: dryRunOption,
   verbose: verboseOption
 }).pipe(Command.withDescription("Create directory structure from a tree representation"), Command.withHandler(({ tree, path: targetPath, dryRun = false, verbose }) => {
-  const readStdin = Effect3.tryPromise({
-    try: () => new Promise((resolve2) => {
-      const rl = createInterface({ input: process.stdin });
-      const lines = [];
-      rl.on("line", (line) => lines.push(line));
-      rl.on("close", () => resolve2(lines.join(`
+  const readStdin = Effect3.gen(function* () {
+    if (process.stdin.isTTY) {
+      yield* Console.log("Paste your tree structure and press Ctrl+D when done:");
+    }
+    return yield* Effect3.tryPromise({
+      try: () => new Promise((resolve2) => {
+        const rl = createInterface({ input: process.stdin });
+        const lines = [];
+        rl.on("line", (line) => lines.push(line));
+        rl.on("close", () => resolve2(lines.join(`
 `)));
-    }),
-    catch: (e) => new Error(`Failed to read stdin: ${String(e)}`)
+      }),
+      catch: (e) => new Error(`Failed to read stdin: ${String(e)}`)
+    });
   });
-  const program = Effect3.gen(function* (_) {
-    const treeString = Option.isSome(tree) ? tree.value : yield* _(readStdin);
+  const program = Effect3.gen(function* () {
+    const treeString = Option.isSome(tree) ? tree.value : yield* readStdin;
     if (dryRun) {
-      yield* _(Effect3.logInfo("Running in dry mode. No one file system node will be created."));
+      yield* Effect3.logInfo("Running in dry mode. No one file system node will be created.");
     }
-    yield* _(Effect3.logInfo("Parsing tree structure..."));
+    yield* Effect3.logInfo("Parsing tree structure...");
     const items = parserFolderStructure(treeString);
     if (items.length === 0) {
-      yield* _(Console.error("No valid items found in the tree structure"));
-      yield* _(Console.error(items));
-      yield* _(Console.error(treeString));
-      return yield* _(Effect3.fail(new Error("Invalid tree structure")));
+      yield* Console.error("No valid items found in the tree structure");
+      return yield* Effect3.fail(new Error("Invalid tree structure"));
     }
-    yield* _(Effect3.logInfo(`Found ${items.length} items to create`));
-    yield* _(Effect3.logInfo(`Found: 
+    yield* Effect3.logInfo(`Found ${items.length} items to create`);
+    yield* Effect3.logInfo(`Found: 
 ${items.map((i) => `${i.path} 
-`).join("")}`));
+`).join("")}`);
     if (!dryRun) {
-      yield* _(fileStructureCreator(items, targetPath));
+      yield* fileStructureCreator(items, targetPath);
     }
   });
   return verbose ? program.pipe(Logger.withMinimumLogLevel(LogLevel.Info)) : program;
 }));
 var cli = Command.run(command, {
-  name: "Touch All",
-  version: "0.0.1"
+  name: package_default.name,
+  version: package_default.version
 });
 
 // src/touch-all.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "touch-all",
-  "version": "1.1.10",
+  "version": "1.2.1",
   "description": "CLI tool to create folder structures from markdown tree representations",
   "keywords": [
     "cli",
@@ -19,7 +19,7 @@
     "touch-all": "dist/slim/touch-all.js"
   },
   "files": [
-    "dist/bundled",
+    "dist/slim",
     "dist/lib"
   ],
   "type": "module",
@@ -39,23 +39,24 @@
     "build": "tsup --config .config/tsup.config.ts",
     "check:lint": "oxlint . -c .config/.oxlintrc.json",
     "check:format": "oxfmt . -c .config/.oxfmtrc.json --check",
+    "check:ts": "tsc --noEmit",
     "format": "oxfmt . -c .config/.oxfmtrc.json --write",
     "test": "vitest --config .config/vitest.config.ts run"
   },
   "dependencies": {
-    "@effect/cli": "^0.73.2",
-    "@effect/platform-node": "^0.104.1",
-    "effect": "^3.19.16"
+    "@effect/cli": "^0.75.0",
+    "@effect/platform-node": "^0.106.0",
+    "effect": "^3.21.0"
   },
   "devDependencies": {
-    "@total-typescript/tsconfig": "1.0.4",
-    "@types/bun": "1.3.9",
-    "@types/node": "25.3.2",
-    "oxfmt": "0.28.0",
-    "oxlint": "1.43.0",
+    "@total-typescript/tsconfig": "1.0.3",
+    "@types/bun": "1.3.11",
+    "@types/node": "25.5.0",
+    "oxfmt": "0.41.0",
+    "oxlint": "1.56.0",
     "tsup": "8.5.1",
     "typescript": "5.9.3",
-    "vitest": "4.0.18"
+    "vitest": "4.1.0"
   },
   "engines": {
     "node": ">=18"