v4.2.0

- Fixed bug where CLI with no args would return entire argv including node path
- Removed debug 'Wanted command: ...' log from startParse()

.smartconfig.json

@@ -1,9 +1,5 @@
 {
-  "npmci": {
+  "@git.zone/cli": {
-    "npmGlobalTools": [],
-    "npmAccesslevel": "public"
-  },
-  "gitzone": {
     "projectType": "npm",
     "module": {
       "githost": "code.foss.global",
@@ -12,23 +8,25 @@
       "description": "A library that simplifies building reactive command-line applications using observables, with robust support for commands, arguments, options, aliases, and asynchronous operation management.",
       "npmPackagename": "@push.rocks/smartcli",
       "license": "MIT",
-      "keywords": [
+      "projectDomain": "push.rocks"
-        "CLI",
+    },
-        "command line",
+    "release": {
-        "observable",
+      "targets": {
-        "reactive",
+        "npm": {
-        "asynchronous",
+          "registries": [
-        "commands",
+            "https://verdaccio.lossless.digital",
-        "arguments",
+            "https://registry.npmjs.org"
-        "options",
+          ],
-        "alias",
+          "accessLevel": "public"
-        "typescript",
+        }
-        "node.js",
-        "development tool"
-      ]
       }
     },
-  "tsdoc": {
+    "schemaVersion": 2
-    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  },
+  "@git.zone/tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [LICENSE](LICENSE) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  },
+  "@ship.zone/szci": {
+    "npmGlobalTools": []
   }
 }

.vscode/settings.json

@@ -1,26 +0,0 @@
-{
-  "json.schemas": [
-    {
-      "fileMatch": ["/npmextra.json"],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "npmci": {
-            "type": "object",
-            "description": "settings for npmci"
-          },
-          "gitzone": {
-            "type": "object",
-            "description": "settings for gitzone",
-            "properties": {
-              "projectType": {
-                "type": "string",
-                "enum": ["website", "element", "service", "npm", "wcc"]
-              }
-            }
-          }
-        }
-      }
-    }
-  ]
-}

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Push.Rocks
+Copyright (c) 2015 Task Venture Capital GmbH
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

changelog.md

@@ -1,5 +1,90 @@
 # Changelog
 
+## Pending
+
+
+
+## 2026-05-13 - 4.2.0
+
+### Features
+
+- enhance terminal task rendering with progress, lifecycle helpers, and configurable output modes (terminal)
+  - add task progress reporting and task.run() helpers for automatic completion and failure handling
+  - support configurable unicode or ascii symbols, cleanup behavior, and throttled non-interactive lifecycle logs
+  - export new terminal task run and symbol mode types and document the updated terminal API
+
+## 2026-05-13 - 4.1.0
+
+### Features
+
+- add live terminal task rendering with interactive and non-interactive output modes (terminal)
+  - introduces SmartcliTerminal and SmartcliTerminalTask exports for fixed-row task rendering
+  - supports task updates, completion, failure handling, and persistent error output
+  - detects interactive terminals and falls back to append-only logs in CI or non-TTY environments
+  - adds tests covering interactive rendering, non-interactive logging, and error attachment behavior
+
+## 2026-04-30 - 4.0.21 - fix(smartcli)
+tighten command parsing and error handling while updating build and package configuration
+
+- throw an explicit error when triggering an unregistered command instead of failing on an undefined subject
+- make the cli version property optional to align with current typing expectations
+- update tests to use explicit argv input and export the tap startup call for runtime compatibility
+- enable stricter TypeScript configuration and refresh build, dependency, and package metadata files
+
+## 2025-10-28 - 4.0.19 - fix(license)
+Update license files and add local tool settings
+
+- Update LICENSE header to reference Task Venture Capital GmbH as copyright holder
+- Add a new license file containing the full MIT license text
+- Add .claude/settings.local.json to store local tool permission settings
+
+## 2025-10-28 - 4.0.18 - fix(smartcli)
+Allow passing argv to startParse and improve getUserArgs Deno/runtime handling; update tests and add license
+
+- Smartcli.startParse now accepts an optional testArgv parameter to bypass automatic runtime detection (makes testing deterministic).
+- getUserArgs logic refined: always prefer Deno.args when available (handles Deno run and compiled executables reliably) and improve execPath fallback and slicing behavior for Node/Bun/other launchers.
+- Tests updated: test/test.node+deno+bun.ts now passes process.argv explicitly to startParse to avoid Deno.args interference in test environments.
+- Added MIT LICENSE file and a local .claude/settings.local.json for environment/permission settings.
+
+## 2025-10-28 - 4.0.17 - fix(license)
+Add MIT license and local Claude settings
+
+- Add LICENSE file (MIT) to repository
+- Add .claude/settings.local.json with local permissions for tooling
+
+## 2025-10-28 - 4.0.16 - fix(smartcli.helpers)
+Improve CLI argument parsing and Deno runtime detection; use getUserArgs consistently
+
+- Enhance getUserArgs() to prefer Deno.args but detect when process.argv was manipulated (e.g. in tests) and fallback to manual parsing
+- Add robust handling of process.execPath / execPath basename and compute correct argv offset for known launchers vs. compiled executables
+- Call getUserArgs() (no explicit process.argv) from Smartcli.getOption and Smartcli.startParse to ensure consistent cross-runtime behavior
+- Expand readme.hints.md with detailed cross-runtime examples and explanation of Deno.args vs process.argv for compiled executables
+- Add local claude settings file for tooling configuration
+
+## 2025-10-28 - 4.0.15 - fix(smartcli.helpers)
+Add robust getUserArgs helper and refactor Smartcli to use it; add MIT license and update documentation
+
+- Add ts/smartcli.helpers.ts: getUserArgs to normalize user arguments across Node.js, Deno (run/compiled), and Bun, with safety checks for test environments
+- Refactor Smartcli (ts/smartcli.classes.smartcli.ts) to use getUserArgs in startParse and getOption for correct argument parsing and improved test compatibility
+- Update readme.hints.md with detailed cross-runtime CLI argument parsing guidance
+- Add LICENSE (MIT) file
+- Add .claude/settings.local.json (local settings)
+
+## 2025-10-28 - 4.0.14 - fix(license)
+Add MIT license file
+
+- Add MIT License file to repository to clarify licensing and copyright (Push.Rocks 2015).
+
+## 2025-10-27 - 4.0.13 - fix(smartcli)
+Improve CLI argument parsing, update deps and tests
+
+- Enhance startParse() to filter runtime executables and script paths (node, deno, bun, tsx, ts-node) so commands are detected correctly across runtimes.
+- Switch path import to node:path in plugins for ESM compatibility.
+- Bump various dependencies and devDependencies (including @push.rocks/lik, @push.rocks/smartlog, @push.rocks/smartpromise, @push.rocks/smartrx, yargs-parser, @git.zone tooling) and add packageManager field.
+- Replace / reorganize tests: add/modify test/test.node+deno+bun.ts, adjust test script to use --verbose.
+- Add deno.lock and include many resolved npm dependencies.
+- Add LICENSE file (MIT).
+
 ## 2025-04-01 - 4.0.12 - fix(docs)
 Update documentation with comprehensive usage examples, improved command alias descriptions, and detailed configuration instructions
 

package.json

@@ -1,14 +1,14 @@
 {
   "name": "@push.rocks/smartcli",
   "private": false,
-  "version": "4.0.12",
+  "version": "4.2.0",
   "description": "A library that simplifies building reactive command-line applications using observables, with robust support for commands, arguments, options, aliases, and asynchronous operation management.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
   "scripts": {
-    "test": "(tstest test/ --web)",
+    "test": "(tstest test/ --verbose)",
-    "build": "(tsbuild --web --allowimplicitany)",
+    "build": "tsbuild --web",
     "buildDocs": "tsdoc"
   },
   "repository": {
@@ -32,23 +32,23 @@
   "author": "Lossless GmbH <office@lossless.com> (https://lossless.com)",
   "license": "MIT",
   "bugs": {
-    "url": "https://gitlab.com/pushrocks/smartcli/issues"
+    "url": "https://code.foss.global/push.rocks/smartcli/issues"
   },
   "homepage": "https://code.foss.global/push.rocks/smartcli",
   "dependencies": {
-    "@push.rocks/lik": "^6.0.15",
+    "@push.rocks/lik": "^6.4.1",
-    "@push.rocks/smartlog": "^3.0.6",
+    "@push.rocks/smartlog": "^3.2.2",
     "@push.rocks/smartobject": "^1.0.12",
-    "@push.rocks/smartpromise": "^4.0.3",
+    "@push.rocks/smartpromise": "^4.2.4",
-    "@push.rocks/smartrx": "^3.0.3",
+    "@push.rocks/smartrx": "^3.0.10",
-    "yargs-parser": "21.1.1"
+    "yargs-parser": "22.0.0"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.80",
+    "@git.zone/tsbuild": "^4.4.1",
-    "@git.zone/tsrun": "^1.2.42",
+    "@git.zone/tsrun": "^2.0.4",
-    "@git.zone/tstest": "^1.0.90",
+    "@git.zone/tstest": "^3.6.6",
-    "@push.rocks/tapbundle": "^5.0.23",
+    "@types/node": "^25.7.0",
-    "@types/node": "^20.12.12"
+    "@types/yargs-parser": "^21.0.3"
   },
   "files": [
     "ts/**/*",
@@ -59,10 +59,12 @@
     "dist_ts_web/**/*",
     "assets/**/*",
     "cli.js",
-    "npmextra.json",
+    ".smartconfig.json",
+    "LICENSE",
     "readme.md"
   ],
   "browserslist": [
     "last 1 chrome versions"
-  ]
+  ],
+  "packageManager": "pnpm@10.28.2"
 }

readme.hints.md

@@ -1 +1,42 @@
-No specific hints.
+## Cross-Runtime Compatibility
+
+### CLI Argument Parsing
+The module uses a robust cross-runtime approach for parsing command-line arguments through the `getUserArgs()` utility in `ts/smartcli.helpers.ts`.
+
+**Runtime-Specific Implementations:**
+
+| Runtime | process.argv Structure | Preferred API | Reason |
+|---------|------------------------|---------------|---------|
+| **Node.js** | `["/path/to/node", "/path/to/script.js", ...userArgs]` | Manual parsing | No native user-args API |
+| **Deno run** | `["deno", "/path/to/script.ts", ...userArgs]` | `Deno.args` ✅ | Pre-filtered by runtime |
+| **Deno compiled** | `["/path/to/binary", "/tmp/deno-compile-.../mod.ts", ...userArgs]` | `Deno.args` ✅ | Filters internal bundle path |
+| **Bun** | `["/path/to/bun", "/path/to/script.ts", ...userArgs]` | Manual parsing | Bun.argv not pre-filtered |
+
+**Why Deno.args is Critical for Compiled Executables:**
+
+Deno compiled executables insert an internal bundle path at `argv[1]`:
+```javascript
+process.argv = [
+  "/usr/local/bin/moxytool",              // argv[0] - executable
+  "/tmp/deno-compile-moxytool/mod.ts",    // argv[1] - INTERNAL bundle path
+  "scripts",                               // argv[2] - actual user command
+  "--option"                               // argv[3+] - user args
+]
+
+Deno.args = ["scripts", "--option"]  // ✓ Correctly filtered by Deno runtime
+```
+
+**getUserArgs() Logic:**
+
+1. **Prefer Deno.args** when available (unless process.argv appears manipulated for testing)
+2. **Fallback to manual parsing** for Node.js and Bun:
+   - Check `process.execPath` basename
+   - Known launchers (node, deno, bun, tsx, ts-node) → skip 2 args
+   - Unknown (compiled executables) → skip 1 arg
+3. **Test detection**: If `process.argv.length > 2` in Deno, use manual parsing (handles test manipulation)
+
+**Key Benefits:**
+- ✅ Works with custom-named compiled executables
+- ✅ Handles Deno's internal bundle path automatically
+- ✅ Compatible with test environments
+- ✅ No heuristics needed for Deno (runtime does the work)

test/test.node+deno+bun.ts

@@ -1,4 +1,4 @@
-import { tap, expect } from '@push.rocks/tapbundle';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
 import * as smartrx from '@push.rocks/smartrx';
 
 import * as smartcli from '../ts/index.js';
@@ -16,10 +16,7 @@ tap.test('should add an command', async (toolsArg) => {
   awesomeCommandSubject.subscribe(() => {
     done.resolve();
   });
-  console.log(process.argv);
+  smartCliTestObject.startParse(['node', 'test.js', 'awesome']);
-  process.argv.splice(2, 0, 'awesome');
-  console.log(process.argv);
-  smartCliTestObject.startParse();
   await done.promise;
 });
 
@@ -39,4 +36,4 @@ tap.test('should accept a command', async () => {
   expect(hasExecuted).toBeTrue();
 });
 
-tap.start();
+export default tap.start();

test/test.terminal.node+deno+bun.ts

@@ -0,0 +1,190 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+
+import * as smartcli from '../ts/index.js';
+
+class TestWritable implements smartcli.ISmartcliWritable {
+  public chunks: string[] = [];
+  public isTTY: boolean;
+  public columns = 80;
+
+  constructor(isTTYArg: boolean) {
+    this.isTTY = isTTYArg;
+  }
+
+  public write(chunkArg: string): boolean {
+    this.chunks.push(chunkArg);
+    return true;
+  }
+
+  public toString(): string {
+    return this.chunks.join('');
+  }
+}
+
+tap.test('should render terminal tasks in non-interactive mode', async () => {
+  const stream = new TestWritable(false);
+  const terminal = new smartcli.SmartcliTerminal({
+    stream,
+    interactive: false,
+    colors: false,
+    symbols: 'ascii',
+    nonInteractiveThrottleMs: 0,
+  });
+  const task = terminal.createTask({ job: 'build package', rows: 2 });
+
+  task.update('running tsbuild');
+  task.complete('done');
+
+  const output = stream.toString();
+  expect(output).toInclude('start build package');
+  expect(output).toInclude('update build package: running tsbuild');
+  expect(output).toInclude('done build package in');
+  expect(output).toInclude(': done');
+  expect(terminal.getTasks()).toHaveLength(0);
+});
+
+tap.test('should render fixed rows in interactive mode', async () => {
+  const stream = new TestWritable(true);
+  const terminal = new smartcli.SmartcliTerminal({
+    stream,
+    interactive: true,
+    colors: false,
+    symbols: 'ascii',
+    cleanup: false,
+  });
+  const task = terminal.createTask({ job: 'install dependencies', rows: 2 });
+
+  task.update('fetching packages');
+
+  const renderedRows = task.renderPlainRows(80);
+  expect(renderedRows).toHaveLength(2);
+  expect(renderedRows[0]).toInclude('* install dependencies');
+  expect(stream.toString()).toInclude('\u001B[?25l');
+  expect(stream.toString()).toInclude('\u001B[2K');
+
+  task.complete('installed');
+
+  expect(stream.toString()).toInclude('OK install dependencies');
+  expect(stream.toString()).toInclude('installed');
+  expect(stream.toString()).toInclude('\u001B[?25h');
+  expect(terminal.getTasks()).toHaveLength(0);
+});
+
+tap.test('should attach persistent terminal task errors', async () => {
+  const stream = new TestWritable(true);
+  const terminal = new smartcli.SmartcliTerminal({
+    stream,
+    interactive: true,
+    colors: false,
+    symbols: 'ascii',
+    cleanup: false,
+  });
+  const task = terminal.createTask({ job: 'deploy release', rows: 3 });
+
+  task.attachError('deployment failed', { keepOpen: true });
+
+  expect(task.status).toEqual('failed');
+  expect(task.getErrorLines()).toContain('deployment failed');
+  expect(task.renderPlainRows(80)[0]).toInclude('X deploy release');
+  expect(terminal.getTasks()).toHaveLength(1);
+
+  terminal.clear();
+});
+
+tap.test('should collapse failed terminal tasks into permanent output', async () => {
+  const stream = new TestWritable(false);
+  const terminal = new smartcli.SmartcliTerminal({
+    stream,
+    interactive: false,
+    colors: false,
+    symbols: 'ascii',
+  });
+  const task = terminal.createTask({ job: 'publish package' });
+
+  task.attachError('registry rejected package');
+
+  const output = stream.toString();
+  expect(output).toInclude('fail publish package in');
+  expect(output).toInclude(': registry rejected package');
+  expect(terminal.getTasks()).toHaveLength(0);
+});
+
+tap.test('should set task progress', async () => {
+  const stream = new TestWritable(true);
+  const terminal = new smartcli.SmartcliTerminal({
+    stream,
+    interactive: true,
+    colors: false,
+    symbols: 'ascii',
+    cleanup: false,
+  });
+  const task = terminal.task('process files', { rows: 2 });
+
+  task.setProgress(2, 5, 'processed files');
+
+  expect(task.getLastLogLine()).toInclude('40% (2/5)');
+  expect(task.renderPlainRows(80)[0]).toInclude('40% (2/5)');
+  terminal.clear();
+});
+
+tap.test('should auto-complete task.run', async () => {
+  const stream = new TestWritable(false);
+  const terminal = new smartcli.SmartcliTerminal({
+    stream,
+    interactive: false,
+    colors: false,
+    nonInteractiveThrottleMs: 0,
+  });
+  const task = terminal.task('run operation');
+
+  const result = await task.run(async (taskArg) => {
+    taskArg.update('inside operation');
+    return 'result';
+  }, { successMessage: 'operation finished' });
+
+  expect(result).toEqual('result');
+  expect(task.status).toEqual('completed');
+  expect(stream.toString()).toInclude('done run operation in');
+  expect(stream.toString()).toInclude('operation finished');
+});
+
+tap.test('should auto-fail task.run', async () => {
+  const stream = new TestWritable(false);
+  const terminal = new smartcli.SmartcliTerminal({ stream, interactive: false, colors: false });
+  const task = terminal.task('failing operation');
+
+  let caughtError: Error | undefined;
+  try {
+    await task.run(async () => {
+      throw new Error('operation failed');
+    });
+  } catch (error) {
+    caughtError = error as Error;
+  }
+
+  expect(caughtError?.message).toEqual('operation failed');
+  expect(task.status).toEqual('failed');
+  expect(stream.toString()).toInclude('fail failing operation in');
+  expect(stream.toString()).toInclude('operation failed');
+});
+
+tap.test('should throttle duplicate non-interactive updates', async () => {
+  const stream = new TestWritable(false);
+  const terminal = new smartcli.SmartcliTerminal({
+    stream,
+    interactive: false,
+    colors: false,
+    nonInteractiveThrottleMs: 10000,
+  });
+  const task = terminal.task('quiet task');
+
+  task.update('same update');
+  task.update('same update');
+  task.update('different but throttled');
+
+  const output = stream.toString();
+  expect(output).toInclude('update quiet task: same update');
+  expect(output).not.toInclude('different but throttled');
+});
+
+export default tap.start();

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartcli',
-  version: '4.0.12',
+  version: '4.2.0',
   description: 'A library that simplifies building reactive command-line applications using observables, with robust support for commands, arguments, options, aliases, and asynchronous operation management.'
 }

ts/index.ts

@@ -1 +1,11 @@
 export { Smartcli } from './smartcli.classes.smartcli.js';
+export { SmartcliTerminal, SmartcliTerminalTask } from './smartcli.classes.terminal.js';
+export type {
+  ISmartcliTerminalAttachErrorOptions,
+  ISmartcliTerminalOptions,
+  ISmartcliTerminalTaskRunOptions,
+  ISmartcliTerminalTaskOptions,
+  ISmartcliWritable,
+  TSmartcliTerminalSymbolMode,
+  TSmartcliTerminalTaskStatus,
+} from './smartcli.classes.terminal.js';

ts/smartcli.classes.smartcli.ts

@@ -1,4 +1,5 @@
 import * as plugins from './smartcli.plugins.js';
+import { getUserArgs } from './smartcli.helpers.js';
 
 // interfaces
 export interface ICommandObservableObject {
@@ -17,7 +18,7 @@ export class Smartcli {
    */
   public parseCompleted = plugins.smartpromise.defer<any>();
 
-  public version: string;
+  public version?: string;
 
   /**
    * map of all Trigger/Observable objects to keep track
@@ -64,6 +65,9 @@ export class Smartcli {
    */
   public triggerCommand(commandNameArg: string, argvObject: any) {
     const triggerSubject = this.getCommandSubject(commandNameArg);
+    if (!triggerSubject) {
+      throw new Error(`No smartcli command registered for ${commandNameArg}`);
+    }
     triggerSubject.next(argvObject);
     return triggerSubject;
   }
@@ -91,7 +95,8 @@ export class Smartcli {
    * getOption
    */
   public getOption(optionNameArg: string) {
-    const parsedYargs = plugins.yargsParser(process.argv);
+    const userArgs = getUserArgs();
+    const parsedYargs = plugins.yargsParser(userArgs);
     return parsedYargs[optionNameArg];
   }
 
@@ -121,26 +126,12 @@ export class Smartcli {
 
   /**
    * start the process of evaluating commands
+   * @param testArgv - Optional argv override for testing (bypasses automatic runtime detection)
    */
-  public startParse(): void {
+  public startParse(testArgv?: string[]): void {
-    const parsedYArgs = plugins.yargsParser(process.argv);
+    // Get user arguments, properly handling Node.js, Deno (run/compiled), and Bun
-
+    const userArgs = testArgv ? getUserArgs(testArgv) : getUserArgs();
-    // lets handle commands
+    const parsedYArgs = plugins.yargsParser(userArgs);
-    let counter = 0;
-    let foundCommand = false;
-    parsedYArgs._ = parsedYArgs._.filter((commandPartArg) => {
-      counter++;
-      if (typeof commandPartArg === 'number') {
-        return true;
-      }
-      if (counter <= 2 && !foundCommand) {
-        const isPath = commandPartArg.startsWith('/');
-        foundCommand = !isPath;
-        return foundCommand;
-      } else {
-        return true;
-      }
-    });
     const wantedCommand = parsedYArgs._[0];
 
     // lets handle some standards
@@ -148,7 +139,6 @@ export class Smartcli {
       console.log(this.version || 'unknown version');
       return;
     }
-    console.log(`Wanted command: ${wantedCommand}`);
     for (const command of this.commandObservableMap.getArray()) {
       if (!wantedCommand) {
         const standardCommand = this.commandObservableMap.findSync((commandArg) => {

ts/smartcli.classes.terminal.ts

@@ -0,0 +1,636 @@
+export type TSmartcliTerminalTaskStatus = 'running' | 'completed' | 'failed';
+export type TSmartcliTerminalSymbolMode = 'auto' | 'unicode' | 'ascii';
+
+export interface ISmartcliWritable {
+  isTTY?: boolean;
+  columns?: number;
+  write(chunk: string): void | boolean;
+}
+
+export interface ISmartcliTerminalOptions {
+  stream?: ISmartcliWritable;
+  interactive?: boolean;
+  colors?: boolean;
+  symbols?: TSmartcliTerminalSymbolMode;
+  cleanup?: boolean;
+  nonInteractiveThrottleMs?: number;
+}
+
+export interface ISmartcliTerminalTaskOptions {
+  job: string;
+  rows?: number;
+  logLimit?: number;
+}
+
+export interface ISmartcliTerminalAttachErrorOptions {
+  keepOpen?: boolean;
+}
+
+export interface ISmartcliTerminalTaskRunOptions {
+  successMessage?: string;
+  errorKeepOpen?: boolean;
+}
+
+interface INonInteractiveLogState {
+  message: string;
+  timestamp: number;
+}
+
+const ansiCodes = {
+  reset: '\u001B[0m',
+  red: '\u001B[31m',
+  green: '\u001B[32m',
+  cyan: '\u001B[36m',
+  gray: '\u001B[90m',
+};
+
+const unicodeSymbols = {
+  running: '●',
+  completed: '✓',
+  failed: '✕',
+};
+
+const asciiSymbols = {
+  running: '*',
+  completed: 'OK',
+  failed: 'X',
+};
+
+/**
+ * A live terminal renderer for multiple fixed-row tasks.
+ * It automatically falls back to append-only logs in non-interactive environments.
+ */
+export class SmartcliTerminal {
+  private stream: ISmartcliWritable;
+  private interactive: boolean;
+  private colors: boolean;
+  private useUnicodeSymbols: boolean;
+  private cleanupEnabled: boolean;
+  private nonInteractiveThrottleMs: number;
+  private tasks: SmartcliTerminalTask[] = [];
+  private renderedLineCount = 0;
+  private lastRenderedOutput = '';
+  private cursorHidden = false;
+  private cleanupRegistered = false;
+  private nonInteractiveLogState = new Map<SmartcliTerminalTask, INonInteractiveLogState>();
+  private cleanupHandlers: Array<() => void> = [];
+
+  constructor(optionsArg: ISmartcliTerminalOptions = {}) {
+    this.stream = optionsArg.stream || getDefaultStream();
+    this.interactive = getInteractiveState(this.stream, optionsArg.interactive);
+    this.colors = optionsArg.colors ?? (this.interactive && !hasEnvFlag('NO_COLOR'));
+    this.useUnicodeSymbols = getUnicodeSymbolState(this.stream, optionsArg.symbols);
+    this.cleanupEnabled = optionsArg.cleanup ?? true;
+    this.nonInteractiveThrottleMs = Math.max(0, optionsArg.nonInteractiveThrottleMs ?? 250);
+  }
+
+  public createTask(optionsArg: ISmartcliTerminalTaskOptions): SmartcliTerminalTask {
+    const task = new SmartcliTerminalTask(this, optionsArg);
+    this.tasks.push(task);
+
+    if (this.interactive) {
+      this.ensureInteractiveSession();
+      this.render();
+    } else {
+      this.writePermanentLine(`start ${task.job}`);
+    }
+
+    return task;
+  }
+
+  public createProcess(optionsArg: ISmartcliTerminalTaskOptions): SmartcliTerminalTask {
+    return this.createTask(optionsArg);
+  }
+
+  public task(jobArg: string, optionsArg: Omit<ISmartcliTerminalTaskOptions, 'job'> = {}) {
+    return this.createTask({
+      ...optionsArg,
+      job: jobArg,
+    });
+  }
+
+  public isInteractive(): boolean {
+    return this.interactive;
+  }
+
+  public getTasks(): SmartcliTerminalTask[] {
+    return [...this.tasks];
+  }
+
+  /** @internal */
+  public updateTask(taskArg: SmartcliTerminalTask, messageArg?: string): void {
+    if (!this.tasks.includes(taskArg)) {
+      return;
+    }
+
+    if (this.interactive) {
+      this.render();
+    } else if (messageArg && this.shouldWriteNonInteractiveUpdate(taskArg, messageArg)) {
+      this.writePermanentLine(`update ${taskArg.job}: ${messageArg}`);
+    }
+  }
+
+  /** @internal */
+  public completeTask(taskArg: SmartcliTerminalTask, messageArg?: string): void {
+    const message = messageArg || taskArg.getLastLogLine();
+    const summary = this.interactive
+      ? `${this.getStatusSymbol('completed')} ${taskArg.job} ${taskArg.getElapsedText()}${message ? ` - ${message}` : ''}`
+      : `done ${taskArg.job} in ${taskArg.getElapsedText()}${message ? `: ${message}` : ''}`;
+    this.finalizeTask(taskArg, [summary], 'completed');
+  }
+
+  /** @internal */
+  public failTask(taskArg: SmartcliTerminalTask, errorLinesArg: string[]): void {
+    const summary = this.interactive
+      ? `${this.getStatusSymbol('failed')} ${taskArg.job} ${taskArg.getElapsedText()}${errorLinesArg[0] ? ` - ${errorLinesArg[0]}` : ''}`
+      : `fail ${taskArg.job} in ${taskArg.getElapsedText()}${errorLinesArg[0] ? `: ${errorLinesArg[0]}` : ''}`;
+    const detailLines = errorLinesArg.slice(1).map((lineArg) => `  ${lineArg}`);
+    this.finalizeTask(taskArg, [summary, ...detailLines], 'failed');
+  }
+
+  public clear(): void {
+    if (this.interactive) {
+      this.clearRenderedBlock();
+      this.restoreCursor();
+    }
+    this.tasks = [];
+    this.nonInteractiveLogState.clear();
+  }
+
+  /** @internal */
+  public getStatusSymbol(statusArg: TSmartcliTerminalTaskStatus): string {
+    const symbols = this.useUnicodeSymbols ? unicodeSymbols : asciiSymbols;
+    return symbols[statusArg];
+  }
+
+  /** @internal */
+  public colorizeLine(lineArg: string, statusArg?: TSmartcliTerminalTaskStatus): string {
+    if (!this.colors) {
+      return lineArg;
+    }
+
+    if (statusArg === 'completed') {
+      return `${ansiCodes.green}${lineArg}${ansiCodes.reset}`;
+    }
+    if (statusArg === 'failed') {
+      return `${ansiCodes.red}${lineArg}${ansiCodes.reset}`;
+    }
+    if (statusArg === 'running') {
+      return `${ansiCodes.cyan}${lineArg}${ansiCodes.reset}`;
+    }
+    if (lineArg.startsWith('  ')) {
+      return `${ansiCodes.gray}${lineArg}${ansiCodes.reset}`;
+    }
+    return lineArg;
+  }
+
+  private ensureInteractiveSession(): void {
+    if (!this.cursorHidden) {
+      this.stream.write('\u001B[?25l');
+      this.cursorHidden = true;
+    }
+
+    if (this.cleanupEnabled && !this.cleanupRegistered) {
+      this.registerProcessCleanup();
+    }
+  }
+
+  private finalizeTask(
+    taskArg: SmartcliTerminalTask,
+    linesArg: string[],
+    statusArg: TSmartcliTerminalTaskStatus
+  ): void {
+    this.tasks = this.tasks.filter((task) => task !== taskArg);
+    this.nonInteractiveLogState.delete(taskArg);
+
+    if (this.interactive) {
+      this.clearRenderedBlock();
+      this.writePermanentLines(linesArg.map((lineArg) => this.colorizeLine(lineArg, statusArg)));
+      this.render();
+      if (this.tasks.length === 0) {
+        this.restoreCursor();
+      }
+    } else {
+      this.writePermanentLines(linesArg);
+    }
+  }
+
+  private render(): void {
+    if (!this.interactive) {
+      return;
+    }
+
+    const width = this.getLineWidth();
+    const lines = this.tasks.flatMap((taskArg) => taskArg.renderPlainRows(width));
+    const coloredLines = lines.map((lineArg) => {
+      const status = lineArg.startsWith('  ') ? undefined : getStatusFromRenderedLine(lineArg, this);
+      return this.colorizeLine(lineArg, status);
+    });
+    const renderedOutput = coloredLines.join('\n');
+
+    if (renderedOutput === this.lastRenderedOutput) {
+      return;
+    }
+
+    if (this.renderedLineCount > 0) {
+      this.stream.write(`\u001B[${this.renderedLineCount}F`);
+    }
+
+    const lineCount = Math.max(this.renderedLineCount, coloredLines.length);
+    for (let index = 0; index < lineCount; index++) {
+      this.stream.write('\u001B[2K\r');
+      if (index < coloredLines.length) {
+        this.stream.write(coloredLines[index]);
+      }
+      this.stream.write('\n');
+    }
+
+    this.renderedLineCount = coloredLines.length;
+    this.lastRenderedOutput = renderedOutput;
+  }
+
+  private clearRenderedBlock(): void {
+    if (this.renderedLineCount === 0) {
+      return;
+    }
+
+    this.stream.write(`\u001B[${this.renderedLineCount}F`);
+    this.stream.write(`\u001B[${this.renderedLineCount}M`);
+    this.renderedLineCount = 0;
+    this.lastRenderedOutput = '';
+  }
+
+  private writePermanentLines(linesArg: string[]): void {
+    for (const line of linesArg) {
+      this.writePermanentLine(line);
+    }
+  }
+
+  private writePermanentLine(lineArg: string): void {
+    this.stream.write(`${lineArg}\n`);
+  }
+
+  private shouldWriteNonInteractiveUpdate(
+    taskArg: SmartcliTerminalTask,
+    messageArg: string
+  ): boolean {
+    const now = Date.now();
+    const previousState = this.nonInteractiveLogState.get(taskArg);
+
+    if (previousState?.message === messageArg) {
+      return false;
+    }
+
+    if (previousState && now - previousState.timestamp < this.nonInteractiveThrottleMs) {
+      return false;
+    }
+
+    this.nonInteractiveLogState.set(taskArg, {
+      message: messageArg,
+      timestamp: now,
+    });
+    return true;
+  }
+
+  private restoreCursor(): void {
+    if (!this.cursorHidden) {
+      return;
+    }
+    this.stream.write('\u001B[?25h');
+    this.cursorHidden = false;
+    this.unregisterProcessCleanup();
+  }
+
+  private registerProcessCleanup(): void {
+    const processObject = getProcessObject();
+    if (!processObject?.once) {
+      return;
+    }
+
+    const restoreOnly = () => {
+      this.clearRenderedBlock();
+      if (this.cursorHidden) {
+        this.stream.write('\u001B[?25h');
+        this.cursorHidden = false;
+      }
+    };
+    const exitWithSignal = (codeArg: number) => {
+      restoreOnly();
+      processObject.exit?.(codeArg);
+    };
+    const throwAfterRestore = (errorArg: unknown) => {
+      restoreOnly();
+      throw errorArg;
+    };
+    const sigintHandler = () => exitWithSignal(130);
+    const sigtermHandler = () => exitWithSignal(143);
+
+    processObject.once('exit', restoreOnly);
+    processObject.once('SIGINT', sigintHandler);
+    processObject.once('SIGTERM', sigtermHandler);
+    processObject.once('uncaughtException', throwAfterRestore);
+    this.cleanupHandlers = [
+      () => processObject.off?.('exit', restoreOnly),
+      () => processObject.off?.('SIGINT', sigintHandler),
+      () => processObject.off?.('SIGTERM', sigtermHandler),
+      () => processObject.off?.('uncaughtException', throwAfterRestore),
+    ];
+    this.cleanupRegistered = true;
+  }
+
+  private unregisterProcessCleanup(): void {
+    for (const cleanupHandler of this.cleanupHandlers) {
+      cleanupHandler();
+    }
+    this.cleanupHandlers = [];
+    this.cleanupRegistered = false;
+  }
+
+  private getLineWidth(): number {
+    return Math.max(20, (this.stream.columns || 80) - 1);
+  }
+}
+
+export class SmartcliTerminalTask {
+  public readonly job: string;
+  public readonly rows: number;
+  public readonly startTime = Date.now();
+  public status: TSmartcliTerminalTaskStatus = 'running';
+  private terminal: SmartcliTerminal;
+  private logLimit: number;
+  private logLines: string[] = [];
+  private errorLines: string[] = [];
+  private progressCurrent?: number;
+  private progressTotal?: number;
+
+  constructor(terminalArg: SmartcliTerminal, optionsArg: ISmartcliTerminalTaskOptions) {
+    this.terminal = terminalArg;
+    this.job = optionsArg.job;
+    this.rows = Math.max(1, Math.floor(optionsArg.rows || 3));
+    this.logLimit = Math.max(this.rows, Math.floor(optionsArg.logLimit || 100));
+  }
+
+  public log(messageArg: string): this {
+    if (this.status !== 'running') {
+      return this;
+    }
+
+    const newLines = normalizeLines(messageArg);
+    this.logLines.push(...newLines);
+    if (this.logLines.length > this.logLimit) {
+      this.logLines.splice(0, this.logLines.length - this.logLimit);
+    }
+
+    this.terminal.updateTask(this, newLines.join('\n'));
+    return this;
+  }
+
+  public update(messageArg: string): this {
+    return this.log(messageArg);
+  }
+
+  public setProgress(currentArg: number, totalArg: number, messageArg?: string): this {
+    if (this.status !== 'running') {
+      return this;
+    }
+
+    this.progressCurrent = Math.max(0, currentArg);
+    this.progressTotal = Math.max(0, totalArg);
+    const progressText = this.getProgressText();
+    this.log(messageArg ? `${messageArg} ${progressText}` : progressText);
+    return this;
+  }
+
+  public async run<T>(
+    operationArg: (taskArg: this) => T | Promise<T>,
+    optionsArg: ISmartcliTerminalTaskRunOptions = {}
+  ): Promise<T> {
+    try {
+      const result = await operationArg(this);
+      this.complete(optionsArg.successMessage);
+      return result;
+    } catch (error) {
+      this.attachError(error, { keepOpen: optionsArg.errorKeepOpen });
+      throw error;
+    }
+  }
+
+  public complete(messageArg?: string): this {
+    if (this.status !== 'running') {
+      return this;
+    }
+
+    this.status = 'completed';
+    this.terminal.completeTask(this, messageArg);
+    return this;
+  }
+
+  public attachError(
+    errorArg: unknown,
+    optionsArg: ISmartcliTerminalAttachErrorOptions = {}
+  ): this {
+    if (this.status !== 'running') {
+      return this;
+    }
+
+    this.status = 'failed';
+    this.errorLines = formatError(errorArg);
+
+    if (optionsArg.keepOpen) {
+      this.terminal.updateTask(this, this.errorLines.join('\n'));
+    } else {
+      this.terminal.failTask(this, this.errorLines);
+    }
+
+    return this;
+  }
+
+  public fail(errorArg: unknown): this {
+    return this.attachError(errorArg);
+  }
+
+  public getElapsedText(): string {
+    return formatDuration(Date.now() - this.startTime);
+  }
+
+  public getLastLogLine(): string | undefined {
+    return this.logLines[this.logLines.length - 1];
+  }
+
+  public getLogLines(): string[] {
+    return [...this.logLines];
+  }
+
+  public getErrorLines(): string[] {
+    return [...this.errorLines];
+  }
+
+  /** @internal */
+  public renderPlainRows(widthArg: number): string[] {
+    const lines: string[] = [];
+    const detailLines = this.errorLines.length > 0 ? this.errorLines : this.logLines;
+    const header = this.getHeaderLine();
+
+    if (this.rows === 1) {
+      const lastDetail = detailLines[detailLines.length - 1];
+      lines.push(`${header}${lastDetail ? ` - ${lastDetail}` : ''}`);
+      return lines.map((lineArg) => truncateLine(lineArg, widthArg));
+    }
+
+    lines.push(header);
+    const visibleDetailLineCount = this.rows - 1;
+    const visibleDetailLines = detailLines.slice(-visibleDetailLineCount);
+    for (const line of visibleDetailLines) {
+      lines.push(`  ${line}`);
+    }
+
+    while (lines.length < this.rows) {
+      lines.push('');
+    }
+
+    return lines.map((lineArg) => truncateLine(lineArg, widthArg));
+  }
+
+  private getHeaderLine(): string {
+    const progressText = this.progressTotal ? ` ${this.getProgressText()}` : '';
+    return `${this.terminal.getStatusSymbol(this.status)} ${this.job}${progressText} ${this.getElapsedText()}`;
+  }
+
+  private getProgressText(): string {
+    if (!this.progressTotal) {
+      return '';
+    }
+
+    const percent = Math.floor((this.progressCurrent || 0) / this.progressTotal * 100);
+    return `${Math.min(100, percent)}% (${this.progressCurrent}/${this.progressTotal})`;
+  }
+}
+
+function getDefaultStream(): ISmartcliWritable {
+  const processObject = getProcessObject();
+  if (processObject?.stdout?.write) {
+    return processObject.stdout;
+  }
+
+  return {
+    isTTY: false,
+    write: (chunkArg: string) => {
+      if (typeof console !== 'undefined') {
+        console.log(chunkArg.replace(/\n$/, ''));
+      }
+    },
+  };
+}
+
+function getInteractiveState(streamArg: ISmartcliWritable, overrideArg?: boolean): boolean {
+  if (typeof overrideArg === 'boolean') {
+    return overrideArg;
+  }
+
+  if (!streamArg.isTTY) {
+    return false;
+  }
+
+  return !(
+    hasEnvFlag('CI') ||
+    hasEnvFlag('GITHUB_ACTIONS') ||
+    hasEnvFlag('JENKINS_URL') ||
+    hasEnvFlag('GITLAB_CI') ||
+    hasEnvFlag('TRAVIS') ||
+    hasEnvFlag('CIRCLECI') ||
+    getEnvValue('TERM') === 'dumb'
+  );
+}
+
+function getUnicodeSymbolState(
+  streamArg: ISmartcliWritable,
+  modeArg: TSmartcliTerminalSymbolMode = 'auto'
+): boolean {
+  if (modeArg === 'unicode') {
+    return true;
+  }
+  if (modeArg === 'ascii') {
+    return false;
+  }
+
+  const processObject = getProcessObject();
+  if (processObject?.platform === 'win32' && !getEnvValue('WT_SESSION')) {
+    return false;
+  }
+
+  return streamArg.isTTY !== false && getEnvValue('TERM') !== 'dumb';
+}
+
+function getStatusFromRenderedLine(
+  lineArg: string,
+  terminalArg: SmartcliTerminal
+): TSmartcliTerminalTaskStatus | undefined {
+  if (lineArg.startsWith(terminalArg.getStatusSymbol('completed'))) {
+    return 'completed';
+  }
+  if (lineArg.startsWith(terminalArg.getStatusSymbol('failed'))) {
+    return 'failed';
+  }
+  if (lineArg.startsWith(terminalArg.getStatusSymbol('running'))) {
+    return 'running';
+  }
+  return undefined;
+}
+
+function hasEnvFlag(nameArg: string): boolean {
+  const value = getEnvValue(nameArg);
+  return Boolean(value && value !== '0' && value.toLowerCase() !== 'false');
+}
+
+function getEnvValue(nameArg: string): string | undefined {
+  return getProcessObject()?.env?.[nameArg];
+}
+
+function getProcessObject(): any {
+  const globalObject: any = globalThis as any;
+  return globalObject.process;
+}
+
+function normalizeLines(messageArg: string): string[] {
+  return String(messageArg)
+    .split(/\r?\n/)
+    .map((lineArg) => lineArg.trimEnd())
+    .filter((lineArg) => lineArg.length > 0);
+}
+
+function formatError(errorArg: unknown): string[] {
+  if (errorArg instanceof Error) {
+    return normalizeLines(errorArg.stack || errorArg.message || errorArg.name);
+  }
+
+  if (typeof errorArg === 'string') {
+    return normalizeLines(errorArg);
+  }
+
+  try {
+    const jsonString = JSON.stringify(errorArg);
+    return normalizeLines(jsonString === undefined ? String(errorArg) : jsonString);
+  } catch {
+    return [String(errorArg)];
+  }
+}
+
+function formatDuration(millisecondsArg: number): string {
+  if (millisecondsArg < 1000) {
+    return `${millisecondsArg}ms`;
+  }
+
+  return `${(millisecondsArg / 1000).toFixed(1)}s`;
+}
+
+function truncateLine(lineArg: string, widthArg: number): string {
+  if (lineArg.length <= widthArg) {
+    return lineArg;
+  }
+
+  if (widthArg <= 3) {
+    return lineArg.slice(0, widthArg);
+  }
+
+  return `${lineArg.slice(0, widthArg - 3)}...`;
+}

ts/smartcli.helpers.ts

@@ -0,0 +1,76 @@
+/**
+ * Return only the user arguments (excluding runtime executable and script path),
+ * across Node.js, Deno (run/compiled), and Bun.
+ *
+ * - Deno: uses Deno.args directly (already user-only in both run and compile).
+ * - Node/Bun: uses process.execPath's basename to decide if there is a script arg.
+ *   If execPath basename is a known launcher (node/nodejs/bun/deno), skip 2; else skip 1.
+ */
+export function getUserArgs(argv?: string[]): string[] {
+  // If argv is explicitly provided, use it instead of Deno.args
+  // This handles test scenarios where process.argv is manually modified
+  const useProvidedArgv = argv !== undefined;
+
+  // Prefer Deno.args when available and no custom argv provided;
+  // it's the most reliable for Deno run and compiled.
+  // Deno.args is ALWAYS correct in Deno environments - it handles the internal bundle path automatically.
+  // deno-lint-ignore no-explicit-any
+  const g: any = typeof globalThis !== 'undefined' ? globalThis : {};
+
+  if (!useProvidedArgv && g.Deno && g.Deno.args && Array.isArray(g.Deno.args)) {
+    return g.Deno.args.slice();
+  }
+
+  const a = argv ?? (typeof process !== 'undefined' && Array.isArray(process.argv) ? process.argv : []);
+
+  if (!Array.isArray(a) || a.length === 0) return [];
+
+  // Determine execPath in Node/Bun (or compat shims)
+  let execPath = '';
+  if (typeof process !== 'undefined' && typeof process.execPath === 'string') {
+    execPath = process.execPath;
+  } else if (g.Deno && typeof g.Deno.execPath === 'function') {
+    // Fallback for unusual shims: try Deno.execPath() if present.
+    try {
+      execPath = g.Deno.execPath();
+    } catch {
+      /* ignore */
+    }
+  }
+
+  const base = basename(execPath).toLowerCase();
+  const knownLaunchers = new Set([
+    'node',
+    'node.exe',
+    'nodejs',
+    'nodejs.exe',
+    'bun',
+    'bun.exe',
+    'deno',
+    'deno.exe',
+    'tsx',
+    'tsx.exe',
+    'ts-node',
+    'ts-node.exe',
+  ]);
+
+  // Always skip the executable (argv[0]).
+  let offset = Math.min(1, a.length);
+
+  // If the executable is a known runtime launcher, there's almost always a script path in argv[1].
+  // This handles Node, Bun, and "deno run" (but NOT "deno compile" which won't match 'deno').
+  if (knownLaunchers.has(base)) {
+    offset = Math.min(2, a.length);
+  }
+
+  // Note: we intentionally avoid path/URL heuristics on argv[1] so we don't
+  // accidentally drop the first user arg when it's a path-like value in compiled mode.
+  // When offset >= a.length, this correctly returns an empty array (no user args).
+  return a.slice(offset);
+}
+
+function basename(p: string): string {
+  if (!p) return '';
+  const parts = p.split(/[/\\]/);
+  return parts[parts.length - 1] || '';
+}

ts/smartcli.plugins.ts

@@ -1,7 +1,7 @@
 // @pushrocks scope
 import * as smartlog from '@push.rocks/smartlog';
 import * as lik from '@push.rocks/lik';
-import * as path from 'path';
+import * as path from 'node:path';
 import * as smartparam from '@push.rocks/smartobject';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrx from '@push.rocks/smartrx';

tsconfig.json

@@ -5,10 +5,10 @@
     "target": "ES2022",
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
+    "noImplicitAny": true,
     "esModuleInterop": true,
-    "verbatimModuleSyntax": true
+    "verbatimModuleSyntax": true,
+    "types": ["node"]
   },
-  "exclude": [
+  "exclude": ["dist_*/**/*.d.ts"]
-    "dist_*/**/*.d.ts"
-  ]
 }