touch-all 2.0.0 → 2.1.1

package/README.md

@@ -10,12 +10,13 @@ It behaves like `mkdir -p` and `touch` combined, creating directories and files
 
 - Accepts tree strings in **box-drawing** (`├──`, `└──`, `│`) or **indentation** (spaces) format
 - Trailing slash `/` marks a directory; no trailing `/` marks a file
-- Inline comments stripped automatically (`# ...`, `// ...`, `<- ...`, `← ...`)
 - Symlink creation with `link-name -> target` syntax
-- `--dry-run` parses and validates without touching the file system
-- `--verbose` prints every created path
-- Path traversal protection — no item can escape the target directory
+- Inline comments stripped automatically (`# ...`, `// ...`, `<- ...`, `← ...`)
+- `--dry-run` (`-n`) parses and validates without touching the file system
+- Prints a summary line on success (`✓ Done. N items created.`); `--verbose` adds per-item detail
+- Path traversal protection — no file, folder, or symlink target can escape the target directory
 - Importable as a Node.js library with full TypeScript types
+- Pipable interface to run as `echo tree | touch-all` in CI or scripts
 
 ## Installation
 
@@ -60,7 +61,7 @@ touch-all "..." --dry-run
 touch-all "..." -n
 ```
 
-- `--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`
+- `--verbose` , `-v` – prints every created path to the console. Useful for seeing exactly what will be created, especially with complex structures. By default only a summary line is printed on success (`✓ Done. N items created.`). `--verbose` adds per-item detail.
 
 ```bash
 touch-all "..." --verbose
@@ -120,10 +121,10 @@ Both formats produce identical results.
 | `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)               |
-| `... ← comment`   | ignored (stripped)               |
+| `... ←  comment`  | ignored (stripped)               |
 | `name -> target`  | symlink pointing to `target`     |
 
 Items at the root level (no indentation / no parent) are created directly inside the target directory.
@@ -134,17 +135,19 @@ Use `link-name -> target` to create a symlink. The target is passed as-is to the
 
 ```
 my-project/
-  src/
-    index.ts
-    utils -> ../shared/utils.ts   # symlink to a sibling directory
-  shared/
-    utils.ts
+├─ src/
+│  ├─ index.ts
+│  └─ utils -> ../shared/utils.ts   # symlink to a sibling directory
+└─ shared/
+   └─ utils.ts
 ```
 
 If `target` ends with `/`, the symlink is created as a directory symlink (relevant on Windows). The link name's suffix is ignored.
 
 > [!WARNING]
 > If any symlink target resolves outside the project root (`--path`), `touch-all` will prompt for confirmation before proceeding. Use `--yes` to skip the prompt in scripts or CI.
+>
+> When using `fileStructureCreator` directly as a library, outside-root symlinks are rejected by default with a `PathTraversalError`. Pass `{ allowOutsideSymlinks: true }` as the third argument to allow them.
 
 ## Library API
 
@@ -157,8 +160,8 @@ import {
   parserFolderStructure,
   fileStructureCreator,
   resolveProjectPathToBase,
+  isSymlinkOutsideRoot,
   PathTraversalError,
-  FsError,
 } from 'touch-all'
 import type { ParserResult, ParserResultLineItem } from 'touch-all'
 ```
@@ -189,10 +192,12 @@ const items = parserFolderStructure(`
 // ]
 ```
 
-### `fileStructureCreator(items: ParserResult, basePath: string): Effect<void, FsError | PathTraversalError>`
+### `fileStructureCreator(items, basePath, options?): Effect<void, PathTraversalError>`
 
 Creates the parsed structure on disk under `basePath`. Returns an [Effect](https://effect.website/).
 
+By default, symlinks whose targets resolve outside `basePath` are rejected with `PathTraversalError`. Pass `{ allowOutsideSymlinks: true }` to allow them.
+
 ```ts
 import { Effect } from 'effect'
 import { NodeContext, NodeRuntime } from '@effect/platform-node'
@@ -200,22 +205,45 @@ import { NodeContext, NodeRuntime } from '@effect/platform-node'
 const projectDirectory = '/absolute/target/path'
 const items = parserFolderStructure(tree)
 
+// Default: outside-root symlinks are rejected
 fileStructureCreator(items, projectDirectory).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain)
+
+// Opt out of symlink containment check
+fileStructureCreator(items, projectDirectory, { allowOutsideSymlinks: true }).pipe(
+  Effect.provide(NodeContext.layer),
+  NodeRuntime.runMain
+)
+```
+
+### `isSymlinkOutsideRoot(linkPath, target, basePath, path): boolean`
+
+Pure function that returns `true` if a symlink target resolves outside `basePath`. Useful for pre-validating items before passing them to `fileStructureCreator`.
+
+```ts
+import { Path } from '@effect/platform'
+import { Effect } from 'effect'
+import { NodeContext } from '@effect/platform-node'
+import { isSymlinkOutsideRoot } from 'touch-all'
+
+Effect.gen(function* () {
+  const path = yield* Path.Path
+  const outside = isSymlinkOutsideRoot('src/link', '../../etc/passwd', '/project', path)
+  // true — target escapes /project
+}).pipe(Effect.provide(NodeContext.layer))
 ```
 
 ### `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]
+> [!WARNING]
 > `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                                                     |
-| -------------------- | ---------------------- | --------------------------------------------------------------- |
-| `PathTraversalError` | `'PathTraversalError'` | Resolved path escapes `basePath`, or `basePath` is not absolute |
-| `FsError`            | `'FsError'`            | `mkdirSync`, `writeFileSync`, or `symlinkSync` fails            |
+| Class                | `_tag`                 | When thrown                                                                |
+| -------------------- | ---------------------- | -------------------------------------------------------------------------- |
+| `PathTraversalError` | `'PathTraversalError'` | A file/folder path or symlink target escapes `basePath` (unless opted out) |
 
 ## License
 

package/dist/lib/cli.d.ts

@@ -0,0 +1,2 @@
+import { Effect } from 'effect';
+export declare const cli: (args: ReadonlyArray<string>) => Effect.Effect<void, import("./errors").PathTraversalError | import("@effect/platform/Error").PlatformError | Error | import("@effect/cli/ValidationError").ValidationError, import("@effect/cli/CliApp").CliApp.Environment>;

package/dist/lib/{src/_commonErrors.d.ts → errors.d.ts}

@@ -7,12 +7,3 @@ export declare class PathTraversalError {
     constructor(path: string);
     toString(): string;
 }
-/**
- * Error type for file system operation failures
- */
-export declare class FsError {
-    readonly message: string;
-    readonly _tag = "FsError";
-    constructor(message: string);
-    toString(): string;
-}

package/dist/lib/fsGenerator.d.ts

@@ -0,0 +1,7 @@
+import { FileSystem, Path } from '@effect/platform';
+import { Effect } from 'effect';
+import { type ParserResult } from './types';
+import { PathTraversalError } from './errors';
+export declare const fileStructureCreator: (items: ParserResult, basePath: string, options?: {
+    allowOutsideSymlinks?: boolean;
+}) => Effect.Effect<void, PathTraversalError | import("@effect/platform/Error").PlatformError, Path.Path | FileSystem.FileSystem>;

package/dist/lib/fsNormalizator.d.ts

@@ -0,0 +1,20 @@
+import { Path } from '@effect/platform';
+import { Effect } from 'effect';
+import { PathTraversalError } from './errors';
+/**
+ * Returns true if the symlink target escapes the base directory.
+ *
+ * @param linkPath string - Path of the symlink relative to project root.
+ * @param target string - The symlink target value.
+ * @param basePath string - Project root (absolute or relative).
+ * @param path Path.Path - Platform path service instance.
+ */
+export declare const isSymlinkOutsideRoot: (linkPath: string, target: string, basePath: string, path: Path.Path) => boolean;
+/**
+ * Safely normalize a user-supplied path against a base directory.
+ * Fails with PathTraversalError if the resolved path escapes the base.
+ *
+ * @param projectPath string - Path relative to project.
+ * @param basePath string - Must be absolute.
+ */
+export declare const resolveProjectPathToBase: (projectPath: string, basePath: string) => Effect.Effect<string, PathTraversalError, Path.Path>;

package/dist/lib/index.d.ts

@@ -0,0 +1,5 @@
+export { fileStructureCreator } from './fsGenerator';
+export { isSymlinkOutsideRoot, resolveProjectPathToBase } from './fsNormalizator';
+export { PathTraversalError } from './errors';
+export type { ParserResult, ParserResultLineItem } from './types';
+export { parserFolderStructure } from './parser';

package/dist/lib/index.js

@@ -768,12 +768,9 @@ var TypeId3 = TypeId2;
 var Path2 = Path;
 var layer2 = layer;
 // src/fsGenerator.ts
-import { Effect as Effect4 } from "effect";
+import { Console, Effect as Effect4 } from "effect";
 
-// src/fsNormalizator.ts
-import { Effect as Effect3 } from "effect";
-
-// src/_commonErrors.ts
+// src/errors.ts
 class PathTraversalError {
   path;
   _tag = "PathTraversalError";
@@ -781,22 +778,18 @@ class PathTraversalError {
     this.path = path;
   }
   toString() {
-    return `${this._tag}: The path cannot be used ${this.path}`;
-  }
-}
-
-class FsError {
-  message;
-  _tag = "FsError";
-  constructor(message) {
-    this.message = message;
-  }
-  toString() {
-    return `${this._tag}: ${this.message}`;
+    return `${this._tag}: path escapes root — ${this.path}`;
   }
 }
 
 // src/fsNormalizator.ts
+import { Effect as Effect3 } from "effect";
+var isSymlinkOutsideRoot = (linkPath, target, basePath, path) => {
+  const resolvedBase = path.resolve(basePath);
+  const symlinkDir = path.resolve(resolvedBase, path.dirname(linkPath));
+  const resolvedTarget = path.resolve(symlinkDir, target);
+  return path.relative(resolvedBase, resolvedTarget).startsWith("..");
+};
 var resolveProjectPathToBase = (projectPath, basePath) => Effect3.gen(function* () {
   const path = yield* exports_Path.Path;
   const filePath = projectPath.startsWith(path.sep) ? `.${projectPath}` : projectPath;
@@ -809,7 +802,7 @@ var resolveProjectPathToBase = (projectPath, basePath) => Effect3.gen(function*
 });
 
 // src/fsGenerator.ts
-var fileStructureCreator = (items, basePath) => Effect4.gen(function* () {
+var fileStructureCreator = (items, basePath, options) => Effect4.gen(function* () {
   const fs = yield* exports_FileSystem.FileSystem;
   const path = yield* exports_Path.Path;
   yield* Effect4.logInfo(`Creating structure in: ${basePath}`);
@@ -823,6 +816,9 @@ var fileStructureCreator = (items, basePath) => Effect4.gen(function* () {
         yield* Effect4.logInfo(`  Created file:      ${item.path}`);
         break;
       case "symlink":
+        if (!options?.allowOutsideSymlinks && isSymlinkOutsideRoot(item.path, item.target, basePath, path)) {
+          yield* Effect4.fail(new PathTraversalError(`symlink target escapes root: ${item.path} -> ${item.target} (base: ${basePath})`));
+        }
         yield* fs.makeDirectory(dir, { recursive: true });
         yield* fs.symlink(item.target, fullPath);
         yield* Effect4.logInfo(`  Created symlink:   ${item.path} -> ${item.target}`);
@@ -833,8 +829,7 @@ var fileStructureCreator = (items, basePath) => Effect4.gen(function* () {
         break;
     }
   }
-  yield* Effect4.logInfo(`
-✓ Structure created successfully!`);
+  yield* Console.log(`✓ Done. ${items.length} items created.`);
 });
 // src/parser.ts
 var parserFolderStructure = (treeString) => {
@@ -895,7 +890,7 @@ function countLeadingSpaces(str) {
 export {
   resolveProjectPathToBase,
   parserFolderStructure,
+  isSymlinkOutsideRoot,
   fileStructureCreator,
-  PathTraversalError,
-  FsError
+  PathTraversalError
 };

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

@@ -1,2 +1,2 @@
-import type { ParserResult } from './_commonTypes';
+import type { ParserResult } from './types';
 export declare const parserFolderStructure: (treeString: string) => ParserResult;

package/dist/lib/stdin.d.ts

@@ -0,0 +1,2 @@
+import { Effect } from 'effect';
+export declare const readStdin: Effect.Effect<string, Error, never>;

package/dist/lib/symlinkGuard.d.ts

@@ -0,0 +1,4 @@
+import { Path, Terminal } from '@effect/platform';
+import { Effect } from 'effect';
+import { type ParserResult } from './types';
+export declare const parseAndGuardSymlinks: (treeString: string, projectRoot: string, yes: boolean) => Effect.Effect<ParserResult, Error, Path.Path | Terminal.Terminal>;

package/dist/slim/touch-all.js

@@ -15,12 +15,12 @@ var __export = (target, all) => {
 };
 
 // src/touch-all.ts
-import { Effect as Effect6, Logger as Logger2, LogLevel as LogLevel2 } from "effect";
+import { Effect as Effect8, Logger as Logger2, LogLevel as LogLevel2 } from "effect";
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
 
 // src/cli.ts
-import { createInterface } from "node:readline";
 import { Args, Command as Command2, Options } from "@effect/cli";
+import { Console as Console3, Effect as Effect7, Logger, LogLevel, Option as Option2 } from "effect";
 // node_modules/@effect/platform/dist/esm/FileSystem.js
 var exports_FileSystem = {};
 __export(exports_FileSystem, {
@@ -794,8 +794,73 @@ class QuitException extends (/* @__PURE__ */ TaggedError2("QuitException")) {
 }
 var isQuitException = (u) => typeof u === "object" && u != null && ("_tag" in u) && u._tag === "QuitException";
 var Terminal = tag2;
-// src/cli.ts
-import { Console, Effect as Effect5, Logger, LogLevel, Option as Option2 } from "effect";
+// src/fsGenerator.ts
+import { Console, Effect as Effect4 } from "effect";
+
+// src/errors.ts
+class PathTraversalError {
+  path;
+  _tag = "PathTraversalError";
+  constructor(path) {
+    this.path = path;
+  }
+  toString() {
+    return `${this._tag}: path escapes root — ${this.path}`;
+  }
+}
+
+// src/fsNormalizator.ts
+import { Effect as Effect3 } from "effect";
+var isSymlinkOutsideRoot = (linkPath, target, basePath, path) => {
+  const resolvedBase = path.resolve(basePath);
+  const symlinkDir = path.resolve(resolvedBase, path.dirname(linkPath));
+  const resolvedTarget = path.resolve(symlinkDir, target);
+  return path.relative(resolvedBase, resolvedTarget).startsWith("..");
+};
+var resolveProjectPathToBase = (projectPath, basePath) => Effect3.gen(function* () {
+  const path = yield* exports_Path.Path;
+  const filePath = projectPath.startsWith(path.sep) ? `.${projectPath}` : projectPath;
+  const absolute = path.resolve(basePath, filePath);
+  const rel = path.relative(basePath, absolute);
+  if (rel.startsWith("..")) {
+    return yield* Effect3.fail(new PathTraversalError(["project:", projectPath, "base:", basePath].join(" ")));
+  }
+  return absolute;
+});
+
+// src/fsGenerator.ts
+var fileStructureCreator = (items, basePath, options) => Effect4.gen(function* () {
+  const fs = yield* exports_FileSystem.FileSystem;
+  const path = yield* exports_Path.Path;
+  yield* Effect4.logInfo(`Creating structure in: ${basePath}`);
+  for (const item of items) {
+    const fullPath = yield* resolveProjectPathToBase(item.path, basePath);
+    const dir = path.dirname(fullPath);
+    switch (item.type) {
+      case "file":
+        yield* fs.makeDirectory(dir, { recursive: true });
+        yield* fs.writeFile(fullPath, new Uint8Array);
+        yield* Effect4.logInfo(`  Created file:      ${item.path}`);
+        break;
+      case "symlink":
+        if (!options?.allowOutsideSymlinks && isSymlinkOutsideRoot(item.path, item.target, basePath, path)) {
+          yield* Effect4.fail(new PathTraversalError(`symlink target escapes root: ${item.path} -> ${item.target} (base: ${basePath})`));
+        }
+        yield* fs.makeDirectory(dir, { recursive: true });
+        yield* fs.symlink(item.target, fullPath);
+        yield* Effect4.logInfo(`  Created symlink:   ${item.path} -> ${item.target}`);
+        break;
+      case "folder":
+        yield* fs.makeDirectory(fullPath, { recursive: true });
+        yield* Effect4.logInfo(`  Created directory: ${item.path}`);
+        break;
+    }
+  }
+  yield* Console.log(`✓ Done. ${items.length} items created.`);
+});
+
+// src/symlinkGuard.ts
+import { Console as Console2, Effect as Effect5 } from "effect";
 
 // src/parser.ts
 var parserFolderStructure = (treeString) => {
@@ -854,68 +919,52 @@ function countLeadingSpaces(str) {
   return match2 ? match2[0].length : 0;
 }
 
-// src/fsGenerator.ts
-import { Effect as Effect4 } from "effect";
-
-// src/fsNormalizator.ts
-import { Effect as Effect3 } from "effect";
-
-// src/_commonErrors.ts
-class PathTraversalError {
-  path;
-  _tag = "PathTraversalError";
-  constructor(path) {
-    this.path = path;
-  }
-  toString() {
-    return `${this._tag}: The path cannot be used ${this.path}`;
-  }
-}
-
-// src/fsNormalizator.ts
-var resolveProjectPathToBase = (projectPath, basePath) => Effect3.gen(function* () {
-  const path = yield* exports_Path.Path;
-  const filePath = projectPath.startsWith(path.sep) ? `.${projectPath}` : projectPath;
-  const absolute = path.resolve(basePath, filePath);
-  const rel = path.relative(basePath, absolute);
-  if (rel.startsWith("..")) {
-    return yield* Effect3.fail(new PathTraversalError(["project:", projectPath, "base:", basePath].join(" ")));
+// src/symlinkGuard.ts
+var parseAndGuardSymlinks = (treeString, projectRoot, yes) => Effect5.gen(function* () {
+  const nodePath = yield* exports_Path.Path;
+  const items = parserFolderStructure(treeString);
+  const resolvedRoot = nodePath.resolve(projectRoot);
+  const symlinks = items.filter((item) => item.type === "symlink");
+  const outsideSymlinks = symlinks.filter((item) => isSymlinkOutsideRoot(item.path, item.target, resolvedRoot, nodePath));
+  if (outsideSymlinks.length === 0)
+    return items;
+  if (yes)
+    return items;
+  const listing = outsideSymlinks.map((item) => `  ${item.path} -> ${item.target}`).join(`
+`);
+  yield* Console2.error(`Warning: the following symlinks point outside PROJECT_ROOT (${resolvedRoot}):
+${listing}`);
+  const terminal = yield* exports_Terminal.Terminal;
+  yield* terminal.display("Proceed? (y/N) ");
+  const answer = yield* terminal.readLine.pipe(Effect5.catchTag("QuitException", () => Effect5.fail(new Error(`Non-interactive mode: use --yes to allow symlinks outside project root`))));
+  if (answer.trim().toLowerCase() !== "y") {
+    yield* Console2.error("Aborted.");
+    return yield* Effect5.fail(new Error("Aborted by user"));
   }
-  return absolute;
+  return items;
 });
 
-// src/fsGenerator.ts
-var fileStructureCreator = (items, basePath) => Effect4.gen(function* () {
-  const fs = yield* exports_FileSystem.FileSystem;
-  const path = yield* exports_Path.Path;
-  yield* Effect4.logInfo(`Creating structure in: ${basePath}`);
-  for (const item of items) {
-    const fullPath = yield* resolveProjectPathToBase(item.path, basePath);
-    const dir = path.dirname(fullPath);
-    switch (item.type) {
-      case "file":
-        yield* fs.makeDirectory(dir, { recursive: true });
-        yield* fs.writeFile(fullPath, new Uint8Array);
-        yield* Effect4.logInfo(`  Created file:      ${item.path}`);
-        break;
-      case "symlink":
-        yield* fs.makeDirectory(dir, { recursive: true });
-        yield* fs.symlink(item.target, fullPath);
-        yield* Effect4.logInfo(`  Created symlink:   ${item.path} -> ${item.target}`);
-        break;
-      case "folder":
-        yield* fs.makeDirectory(fullPath, { recursive: true });
-        yield* Effect4.logInfo(`  Created directory: ${item.path}`);
-        break;
+// src/stdin.ts
+import { createInterface } from "node:readline";
+import { Effect as Effect6 } from "effect";
+var readStdin = Effect6.tryPromise({
+  try: () => new Promise((resolve3, reject) => {
+    try {
+      const rl = createInterface({ input: process.stdin });
+      const lines = [];
+      rl.on("line", (line) => lines.push(line));
+      rl.on("close", () => resolve3(lines.join(`
+`)));
+    } catch (e) {
+      reject(e);
     }
-  }
-  yield* Effect4.logInfo(`
-✓ Structure created successfully!`);
+  }),
+  catch: (e) => new Error(`Failed to read stdin: ${String(e)}`)
 });
 // package.json
 var package_default = {
   name: "touch-all",
-  version: "2.0.0",
+  version: "2.1.1",
   description: "CLI tool to create folder structures from markdown tree representations",
   keywords: [
     "cli",
@@ -964,7 +1013,6 @@ var package_default = {
     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",
@@ -980,88 +1028,43 @@ var package_default = {
 };
 
 // src/cli.ts
+var { name, version } = package_default;
 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("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 yesOption = Options.boolean("yes").pipe(Options.withAlias("y"), Options.withDefault(false), Options.withDescription("Skip confirmation prompt when symlinks point outside the project root"));
-var command = Command2.make("touch-all", {
+var command = Command2.make(name, {
   tree: treeArg,
   path: pathOption,
   dryRun: dryRunOption,
   verbose: verboseOption,
   yes: yesOption
-}).pipe(Command2.withDescription("Create directory structure from a tree representation"), Command2.withHandler(({ tree, path: targetPath, dryRun = false, verbose, yes }) => {
-  const readStdin = Effect5.gen(function* () {
-    if (process.stdin.isTTY) {
-      yield* Console.log("Paste your tree structure and press Ctrl+D when done:");
-    }
-    return yield* Effect5.tryPromise({
-      try: () => new Promise((resolve3) => {
-        const rl = createInterface({ input: process.stdin });
-        const lines = [];
-        rl.on("line", (line) => lines.push(line));
-        rl.on("close", () => resolve3(lines.join(`
-`)));
-      }),
-      catch: (e) => new Error(`Failed to read stdin: ${String(e)}`)
-    });
-  });
-  const checkOutsideSymlinks = (treeString, projectRoot) => Effect5.gen(function* () {
-    const nodePath = yield* exports_Path.Path;
-    const items = parserFolderStructure(treeString);
-    const resolvedRoot = nodePath.resolve(projectRoot);
-    const outsideSymlinks = items.filter((item) => item.type === "symlink").filter((item) => {
-      const symlinkDir = nodePath.resolve(resolvedRoot, nodePath.dirname(item.path));
-      const resolvedTarget = nodePath.resolve(symlinkDir, item.target);
-      return nodePath.relative(resolvedRoot, resolvedTarget).startsWith("..");
-    });
-    if (outsideSymlinks.length === 0)
-      return items;
-    if (yes)
-      return items;
-    if (!process.stdin.isTTY) {
-      yield* Console.error(`Cannot prompt in non-interactive mode: tree contains symlinks outside PROJECT_ROOT (${resolvedRoot}). Use --yes to proceed.`);
-      return yield* Effect5.fail(new Error("Non-interactive mode with outside symlinks"));
-    }
-    const listing = outsideSymlinks.map((item) => `  ${item.path} -> ${item.type === "symlink" ? item.target : ""}`).join(`
-`);
-    yield* Console.log(`Warning: the following symlinks point outside PROJECT_ROOT (${resolvedRoot}):
-${listing}`);
-    const terminal = yield* exports_Terminal.Terminal;
-    yield* terminal.display("Proceed? (y/N) ");
-    const answer = yield* terminal.readLine.pipe(Effect5.catchTag("QuitException", () => Effect5.succeed("")));
-    if (answer.trim().toLowerCase() !== "y") {
-      yield* Console.log("Aborted.");
-      return yield* Effect5.fail(new Error("Aborted by user"));
-    }
-    return items;
-  });
-  const program = Effect5.gen(function* () {
-    const treeString = Option2.isSome(tree) ? tree.value : yield* readStdin;
+}).pipe(Command2.withDescription("Create directory structure from a tree representation"), Command2.withHandler(({ tree, path: targetPath, dryRun, verbose, yes }) => {
+  const program = Effect7.gen(function* () {
+    const rawTree = Option2.isSome(tree) ? tree.value : yield* readStdin;
+    const treeString = Option2.isSome(tree) ? rawTree.replace(/\\(\\|n)/g, (_, c) => c === "n" ? `
+` : "\\") : rawTree;
     if (dryRun) {
-      yield* Effect5.logInfo("Running in dry mode. No one file system node will be created.");
+      yield* Effect7.logInfo("Dry run: no changes will be made to the file system.");
     }
-    yield* Effect5.logInfo("Parsing tree structure...");
-    const items = yield* checkOutsideSymlinks(treeString, targetPath);
+    yield* Effect7.logInfo("Parsing tree structure...");
+    const items = yield* parseAndGuardSymlinks(treeString, targetPath, yes);
     if (items.length === 0) {
-      yield* Console.error("No valid items found in the tree structure");
-      return yield* Effect5.fail(new Error("Invalid tree structure"));
+      yield* Console3.error("No valid items found in the tree structure");
+      return yield* Effect7.fail(new Error("Invalid tree structure"));
     }
-    yield* Effect5.logInfo(`Found ${items.length} items to create`);
-    yield* Effect5.logInfo(`Found: 
-${items.map((i) => `${i.path} 
-`).join("")}`);
+    yield* Effect7.logInfo(`Found ${items.length} items to create`);
+    yield* Effect7.logInfo(`Found:
+${items.map((i) => i.path).join(`
+`)}`);
     if (!dryRun) {
-      yield* fileStructureCreator(items, targetPath);
+      yield* fileStructureCreator(items, targetPath, { allowOutsideSymlinks: yes });
     }
   });
   return verbose ? program.pipe(Logger.withMinimumLogLevel(LogLevel.Info)) : program;
 }));
-var cli = Command2.run(command, {
-  name: package_default.name,
-  version: package_default.version
-});
+var cli = Command2.run(command, { name, version });
 
 // src/touch-all.ts
-Effect6.suspend(() => cli(process.argv)).pipe(Logger2.withMinimumLogLevel(LogLevel2.Warning), Effect6.provide(NodeContext.layer), NodeRuntime.runMain);
+Effect8.suspend(() => cli(process.argv)).pipe(Logger2.withMinimumLogLevel(LogLevel2.Warning), Effect8.provide(NodeContext.layer), NodeRuntime.runMain);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "touch-all",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "CLI tool to create folder structures from markdown tree representations",
   "keywords": [
     "cli",
@@ -49,7 +49,6 @@
     "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",

package/dist/lib/src/cli.d.ts

@@ -1,2 +0,0 @@
-import { Effect } from 'effect';
-export declare const cli: (args: ReadonlyArray<string>) => Effect.Effect<void, import("./_commonErrors").PathTraversalError | import("@effect/platform/Error").PlatformError | Error | import("@effect/cli/ValidationError").ValidationError, import("@effect/cli/CliApp").CliApp.Environment>;

package/dist/lib/src/fsGenerator.d.ts

@@ -1,4 +0,0 @@
-import { FileSystem, Path } from '@effect/platform';
-import { Effect } from 'effect';
-import { type ParserResult } from './_commonTypes';
-export declare const fileStructureCreator: (items: ParserResult, basePath: string) => Effect.Effect<void, import("./_commonErrors").PathTraversalError | import("@effect/platform/Error").PlatformError, Path.Path | FileSystem.FileSystem>;

package/dist/lib/src/fsNormalizator.d.ts

@@ -1,11 +0,0 @@
-import { Path } from '@effect/platform';
-import { Effect } from 'effect';
-import { PathTraversalError } from './_commonErrors';
-/**
- * Safely normalize a user-supplied path against a base directory.
- * Fails with PathTraversalError if the resolved path escapes the base.
- *
- * @param projectPath string - Path relative to project.
- * @param basePath string - Must be absolute.
- */
-export declare const resolveProjectPathToBase: (projectPath: string, basePath: string) => Effect.Effect<string, PathTraversalError, Path.Path>;

package/dist/lib/src/index.d.ts

@@ -1,5 +0,0 @@
-export { fileStructureCreator } from './fsGenerator';
-export { resolveProjectPathToBase } from './fsNormalizator';
-export { PathTraversalError, FsError } from './_commonErrors';
-export type { ParserResult, ParserResultLineItem } from './_commonTypes';
-export { parserFolderStructure } from './parser';