diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 9695d381..480430f5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,7 +1,5 @@
 name: build
 
-# https://docs.github.com/en/free-pro-team@latest/actions/managing-workflow-runs/adding-a-workflow-status-badge
-
 on:
   push:
     branches: [ master ]
@@ -11,6 +9,7 @@ on:
 jobs:
   build:
     strategy:
+      fail-fast: false
       matrix:
         os:
           - ubuntu-20.04
@@ -18,19 +17,16 @@ jobs:
           - windows-2022
     runs-on: ${{ matrix.os }}
     timeout-minutes: 30
-#    defaults:
-#      run:
-#        shell: bash
-#        working-directory: $GITHUB_WORKSPACE
 
     steps:
       - uses: actions/checkout@v2
-      #      https://stackoverflow.com/questions/56726429/how-to-run-multiple-commands-in-one-github-actions-docker
-
-      - name: Set up JDK 11
-        uses: actions/setup-java@v1
+      - uses: actions/setup-java@v3
         with:
-          java-version: 11
+          distribution: 'zulu'
+          java-version: '11'
+      - uses: fwilhe2/setup-kotlin@main
+        with:
+          version: 1.6.21
 
       - name: Install dependencies for ${{ runner.os }}
         shell: bash
@@ -41,75 +37,10 @@ jobs:
             cp /c/msys64/usr/bin/bash.exe /c/Windows/System32/bash.exe
           fi
 
-#      - name: Update system dependencies
-#        run: |
-#          sudo apt-get update
-#          sudo apt-get install -y curl unzip zip wget
-
-      - name: Install sdkman
-        shell: bash
-        run: |
-          bash -c "curl -s "https://get.sdkman.io" | bash"
-          source "$HOME/.sdkman/bin/sdkman-init.sh"
-
-      - name: Install kotlin
-        shell: bash
-        run: |
-          source "$HOME/.sdkman/bin/sdkman-init.sh"
-          sdk install kotlin 1.4.31
-
-      - name: Install gradle
-        shell: bash
-        run: |
-          source "$HOME/.sdkman/bin/sdkman-init.sh"
-          sdk install gradle 6.7
-
-
-      # https://stackoverflow.com/questions/50104666/gradle-difference-between-test-and-check
-      - name: Build and test with Gradle
-#        working-directory: $GITHUB_WORKSPACE
-        shell: bash
-        run: |
-          echo  $GITHUB_WORKSPACE
-          chmod +x gradlew
-          ./gradlew clean check --stacktrace --info
-
-
-      - name: Build kscript
-        run: ./gradlew assemble
-
-      - name: Install assert.sh
-        shell: bash
-        run: |
-          curl -sLO https://raw.github.com/lehmannro/assert.sh/v1.1/assert.sh
-          chmod +x assert.sh
-
-      # https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#adding-a-system-path
-      - name: Update PATH to include kscript
-        shell: bash
-        run: echo "${GITHUB_WORKSPACE}/build/libs" >> $GITHUB_PATH
-
-      - run: which kscript
-        shell: bash
-
-      - name: Print --version
-        shell: bash
-        run: |
-          source "$HOME/.sdkman/bin/sdkman-init.sh"
-          kscript --version
-
-      - name: Create mock idea executable
-        shell: bash
-        run: |
-          touch idea
-          chmod +x idea
-          echo "${PWD}" >> $GITHUB_PATH
-
       - name: Run tests
         timeout-minutes: 10
         shell: bash
         if: ${{ runner.os != 'Windows' }}
         run: |
-          source "$HOME/.sdkman/bin/sdkman-init.sh"
           export KSCRIPT_HOME="$GITHUB_WORKSPACE"
           ./test/test_suite.sh
diff --git a/NEWS.md b/NEWS.md
index ede88495..74342f4e 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -2,135 +2,158 @@
 
 ## 4.0.0
 
-Rewrite by https://github.com/aartiPl 
+Rewrite by https://github.com/aartiPl
 
 Functionality:
- * Recursive inclusion of dependant scripts without hardcoded limits
+
+* Recursive inclusion of dependant scripts without hardcoded limits
 
 Improved test_suite.sh
- * Automatic setting up of test environment (assert.sh, test directories)
- * Automatic compilation
- * idea - script to help to test idea use cases
- * Script setup_environment.sh can be used for local testing
- * Some script tests moved to Unit Tests
- * Ability to start test suites by name 
+
+* Automatic setting up of test environment (assert.sh, test directories)
+* Automatic compilation
+* idea - script to help to test idea use cases
+* Script setup_environment.sh can be used for local testing
+* Some script tests moved to Unit Tests
+* Ability to start test suites by name
 
 Improved Unit Tests
+
 * Several new Unit tests
 * New Unit Tests can be created much easier (Major point why modularization makes sense)
 
 Improved Logging
+
 * Silent mode / Development mode logging
 
 Modularisation of source code
+
 * Removed duplication
 * Code divided in logical pieces and moved to packages
 * Script resolution creates immutable objects
 
 Build script
-* Updated Gradle to version 7.3 and shadowJar to 6.1.0
+
+* Updated Gradle to version 7.4.3 and shadowJar to 7.1.2
 * Fixes in build file
 
 Performance
+
 * Much less IO operations - that should contribute to better performance
-       
+
 Misc
-* Updated Kotlin to 1.5.31, but only for compiler, not kotlin-scripting. It's far from optimal, but it is not possible to move fully to Kotlin 1.5 or even 1.6, because of the issues with resolution of artifacts in latest kotlin-scripting. I have put report here: https://youtrack.jetbrains.com/issue/KT-49511
+
+* Updated Kotlin to 1.5.31, but only for compiler, not kotlin-scripting. It's far from optimal, but it is not possible
+  to move fully to Kotlin 1.5 or even 1.6, because of the issues with resolution of artifacts in latest
+  kotlin-scripting. I have put report here: https://youtrack.jetbrains.com/issue/KT-49511
 * Fixed a lot of IDE warnings in code
 * Packaging - gradle file converted to Kotlin; still does not work, but it was like that before anyway
-* Changes for kscript dir allow simple implementation of config file if needed. (.kscript/kscript.config); Not implemented by me, but might be useful e.g. for storing preambles
+* Changes for kscript dir allow simple implementation of config file if needed. (.kscript/kscript.config); Not
+  implemented by me, but might be useful e.g. for storing preambles
 
 INCOMPATIBLE CHANGES:
+
 * In annotations the only allowed delimiter is coma "," (to allow options with arguments, separated by space)
-* Resolution of env variables is more restrictive - only vars expected by kscript can be resolved (for security - it's not good to include arbitrary strings from user env into the script)
+* Resolution of env variables is more restrictive - only vars expected by kscript can be resolved (for security - it's
+  not good to include arbitrary strings from user env into the script)
 * Reworked caching mechanism
 
-## 3.2 
+## 3.2
 
 Not released - incorporated in 4.0
 
 Major changes & enhancements
-* Improved for relative script inclusions (Thanks to PR by **aartiPI** [#330](https://github.com/holgerbrandl/kscript/pull/330))
-* Fixed bootstrap header support ([#324](https://github.com/holgerbrandl/kscript/issues/324))
 
+* Improved for relative script inclusions (Thanks to PR by **
+  aartiPI** [#330](https://github.com/holgerbrandl/kscript/pull/330))
+* Fixed bootstrap header support ([#324](https://github.com/holgerbrandl/kscript/issues/324))
 
 ## 3.1
 
 Major changes & enhancements
-* Removed jcenter as default dependency repository 
-* Updated tests and build integration to function without jcenter
 
+* Removed jcenter as default dependency repository
+* Updated tests and build integration to function without jcenter
 
 ## 3.0
 
 Major Enhancements
-* New dependency resolver based on [kotlin-scripting](https://kotlinlang.org/docs/reference/whatsnew14.html#scripting-and-repl)
+
+* New dependency resolver based
+  on [kotlin-scripting](https://kotlinlang.org/docs/reference/whatsnew14.html#scripting-and-repl)
 * Java11 support (fixes #239)
 
 Minor improvements
+
 * Forward jvm target to --idea generated build.gradle.kts (#258)
 * Add maven repo credentials to build.gradle.kts generated by --idea (#262)
-* Add option to launch temp intellij as custom command through env property (#264). E.g on ubuntu we could use `export KSCRIPT_IDEA_COMMAND=/snap/bin/intellij-idea-ultimate` to enable `kscript --idea <script.kts>`
+* Add option to launch temp intellij as custom command through env property (#264). E.g on ubuntu we could
+  use `export KSCRIPT_IDEA_COMMAND=/snap/bin/intellij-idea-ultimate` to enable `kscript --idea <script.kts>`
 * Fixed idea project symlinks for complex projects (#268)
 * Fixed bootstrap script env variable issue (#271)
 * Fixed parsing of named arguments in @MavenRepository (fixes #274)
 * Added executable docker container to release plan (fixes #224)
 * Updated Kotlin to 1.4.10 (#283)
 * Updated gradle in temporary projects to 6.7 (#282)
-* Add Kotlin run configuration for .kt based scripts. (#284) 
+* Add Kotlin run configuration for .kt based scripts. (#284)
 * Use absolute paths to avoid issues with relative paths and relativize (#285)
 
 Incompatible API changes
-* Pom dependencies must be now declared as `org.javamoney:moneta:pom:1.3` (and no longer as `org.javamoney:moneta:1.3@pom`)
+
+* Pom dependencies must be now declared as `org.javamoney:moneta:pom:1.3` (and no longer
+  as `org.javamoney:moneta:1.3@pom`)
 * Dynamic version dependencies must be now declared as `log4j:log4j:[1.2,)` (and no longer as `log4j:log4j:1.2+`)
 
 ## 2.9
 
-
 Support environment variables in repository credentials ([#248](https://github.com/holgerbrandl/kscript/issues/159))
+
 * Make INCLUDE directive files relative to script dir
 * Create a default Run Configuration for Idea ([#244](https://github.com/holgerbrandl/kscript/issues/159))
 
 Minor enhancements & fixes:
+
 * Support whitespace around maven repo credentials (fixes [#228](https://github.com/holgerbrandl/kscript/issues/159))
 * Make INCLUDE directive files relative to script dir
 * Fixed support for gitbash
 * Fixed bootstrap header ([#234](https://github.com/holgerbrandl/kscript/issues/159))
 * Improved and documented basic testing support ([#247](https://github.com/holgerbrandl/kscript/issues/159))
 
-
 ## 2.8
 
 Improvements & Fixes
-* [#214](https://github.com/holgerbrandl/kscript/pull/214) Added credentials support for `@file:MavenRepository` annotation (thanks to [@meonlol](https://github.com/meonlol)
- for providing the PR and his patience)
 
+* [#214](https://github.com/holgerbrandl/kscript/pull/214) Added credentials support for `@file:MavenRepository`
+  annotation (thanks to [@meonlol](https://github.com/meonlol)
+  for providing the PR and his patience)
 
 ## 2.7
 
 Improvements & Fixes
+
 * [#159](https://github.com/holgerbrandl/kscript/issues/159) Use aether instead of maven to pull dependencies
 * [#210](https://github.com/holgerbrandl/kscript/issues/210): Updated gradle capsule plugin
 * [#102](https://github.com/holgerbrandl/kscript/issues/102): Removed `--self-update`
 * Use resource from repo for resolve boostrap header
 * [#203](https://github.com/holgerbrandl/kscript/issues/203): Fix cache check bug on Windows
-* [#199](https://github.com/holgerbrandl/kscript/issues/199): Allow to bootstrap kscript installation with `--add-bootstrap-header`
+* [#199](https://github.com/holgerbrandl/kscript/issues/199): Allow to bootstrap kscript installation
+  with `--add-bootstrap-header`
 * [#200](https://github.com/holgerbrandl/kscript/issues/200): Expose script file name to script
 
-
 ## v2.6
 
-
 Major Improvements
 
 * [#166](https://github.com/holgerbrandl/kscript/issues/166): Support dynamic versions ending with `+`
 * [#185](https://github.com/holgerbrandl/kscript/issues/185): Support "~" in INCLUDE ()
 * [#187](https://github.com/holgerbrandl/kscript/issues/187): Added support for shortened URLs
-* [#146](https://github.com/holgerbrandl/kscript/issues/146): Allow kscript cache directory to be configurable via `KSCRIPT_CACHE_DIR` environment variable
+* [#146](https://github.com/holgerbrandl/kscript/issues/146): Allow kscript cache directory to be configurable
+  via `KSCRIPT_CACHE_DIR` environment variable
 * [#175](https://github.com/holgerbrandl/kscript/issues/175): `cygwin` support improvements
 * Improved `kshell` launcher to also launch scripts with invalid code
 
 Notable Bug Fixes
+
 * Confusing error when filename starts with a number
 * Fixed usage `@file:CompilerOpts` in combination with `@file:Include`
 * Renamed `kshell_from_kscript` to `kshell_kts`
@@ -151,12 +174,14 @@ Minor Enhancements
 * Allow to include same file from multiple files
 * Fixed: Space-containing argument propagation
 
-
 ## v2.4
 
 Major Enhancements:
-* Allow to set `kotlinc` compiler flags with `@file:CompilerOpts` or `//COMPILER_OPTS` (#84). See [here](https://github.com/holgerbrandl/kscript#deploy-scripts-as-standalone-binaries).
-* Provide a way to _package_ kscripts (#63). See [here](https://github.com/holgerbrandl/kscript#configure-the-runtime--with-kotlin_opts).
+
+* Allow to set `kotlinc` compiler flags with `@file:CompilerOpts` or `//COMPILER_OPTS` (#84).
+  See [here](https://github.com/holgerbrandl/kscript#deploy-scripts-as-standalone-binaries).
+* Provide a way to _package_ kscripts (#63).
+  See [here](https://github.com/holgerbrandl/kscript#configure-the-runtime--with-kotlin_opts).
 
 Minor Enhancements:
 
@@ -171,42 +196,46 @@ Minor Enhancements:
 * Simplify Gradle config for script bootstrapping with IDEA (#86)
 * Added Gradle wrapper to the project (#87 and #88)
 
-
 ## v2.3
 
-
 Major Enhancements:
 
 * Replaced `javac` with `kotlinc` for faster script compilation
 * Added symlink support
-* Allow to derive [custom DSL interpreters](https://github.com/holgerbrandl/kscript/blob/master/docs/user_guide.md#create-interpreters-for-custom-dsls) from kscript (fixes  [#67](https://github.com/holgerbrandl/kscript/issues/67))
-* Implemented `@file:Include` and `@EntryPoint` as [documented](https://github.com/holgerbrandl/kscript#annotation-driven-script-configuration) in README (fixes [#73](https://github.com/holgerbrandl/kscript/issues/73))
+* Allow to
+  derive [custom DSL interpreters](https://github.com/holgerbrandl/kscript/blob/master/docs/user_guide.md#create-interpreters-for-custom-dsls)
+  from kscript (fixes  [#67](https://github.com/holgerbrandl/kscript/issues/67))
+* Implemented `@file:Include` and `@EntryPoint`
+  as [documented](https://github.com/holgerbrandl/kscript#annotation-driven-script-configuration) in README (
+  fixes [#73](https://github.com/holgerbrandl/kscript/issues/73))
 * Added [gitter](https://gitter.im/holgerbrandl/kscript?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) channel
 
 Minor Enhancements:
-* Consolidate imports and dependencies when `//INCLUDE` is used (fixes [#75](https://github.com/holgerbrandl/kscript/pull/75)) …
+
+* Consolidate imports and dependencies when `//INCLUDE` is used (
+  fixes [#75](https://github.com/holgerbrandl/kscript/pull/75)) …
 * Support artifact should have better namespace (fixes [#57](https://github.com/holgerbrandl/kscript/issues/57))
 * Fixed [#76](https://github.com/holgerbrandl/kscript/issues/76): Unspecific error when dependency resolution fails
 * Fixed [#66](https://github.com/holgerbrandl/kscript/issues/66): It should die more gracefully if `idea` is not present
 * Fixed [#81](https://github.com/holgerbrandl/kscript/issues/81): Allow package declarations for scripts
-* Fixed [#78](https://github.com/holgerbrandl/kscript/issues/78): When using `--idea` the script argument should be symlinked
+* Fixed [#78](https://github.com/holgerbrandl/kscript/issues/78): When using `--idea` the script argument should be
+  symlinked
 * Fixed [#79](https://github.com/holgerbrandl/kscript/pull/79): Provide setup instructions if idea launcher is missing
 * Simplified build instructions (fixes [#60](https://github.com/holgerbrandl/kscript/issues/60))
 * Document dependencies of kscript (fixes [#69](https://github.com/holgerbrandl/kscript/issues/69))
 
-
 ## v2.2
 
 * Logging of maven artifact downloads to stderr (fixes [#23](https://github.com/holgerbrandl/kscript/issues/23))
 * Added `-s` / `--silent` to suppress all logging
-* Fixed [#55](https://github.com/holgerbrandl/kscript/issues/55): dependency resolution fails on travis ci and within docker containers
-* Added alternative `@DependsOnMaven(val artifactId: String)` annotaiton to declare dependencies. This has been implemented to make kscripts compatible with https://github.com/ligee/kotlin-jupyter
+* Fixed [#55](https://github.com/holgerbrandl/kscript/issues/55): dependency resolution fails on travis ci and within
+  docker containers
+* Added alternative `@DependsOnMaven(val artifactId: String)` annotaiton to declare dependencies. This has been
+  implemented to make kscripts compatible with https://github.com/ligee/kotlin-jupyter
 * Added support for custom maven repositories (fixes [#22](https://github.com/holgerbrandl/kscript/issues/22))
 
-
 See [README.md](README.md) for usage details.
 
-
 ## v2.1
 
 * support for annotation-driven script configuration
@@ -217,59 +246,67 @@ See [README.md](README.md) for usage details.
 * Reimplemented in kotlin (fixes [#36](https://github.com/holgerbrandl/kscript/issues/36))
 * Added cygwin support (fixes [#39](https://github.com/holgerbrandl/kscript/issues/39))
 * Added `//INCLUDE` directive (fixes [#34](https://github.com/holgerbrandl/kscript/issues/34)
-* Fixed: interactive mode is not correctly started when using stdin as script argument ([#40](https://github.com/holgerbrandl/kscript/issues/40)
+* Fixed: interactive mode is not correctly started when using stdin as script
+  argument ([#40](https://github.com/holgerbrandl/kscript/issues/40)
 * Fixed compatibility with java9 ([#41](https://github.com/holgerbrandl/kscript/issues/41))
 
-
 ## v1.5.1
 
 * Fixed `--self-update`
 * More robust self-update on OSses with file-locking (e.g. windows)
 
-
-
 ## v1.5
 
 * removed `curl` dependency
 * more streamlined dependency lookup
 
-
 ## v1.4
 
 Major new features
-* Redesigned [support library](https://github.com/holgerbrandl/kscript-support-api) for streamlined tabular data processing. See [here](http://holgerbrandl.github.io/kotlin/2017/05/08/kscript_as_awk_substitute.html) for an overview.
 
+* Redesigned [support library](https://github.com/holgerbrandl/kscript-support-api) for streamlined tabular data
+  processing. See [here](http://holgerbrandl.github.io/kotlin/2017/05/08/kscript_as_awk_substitute.html) for an
+  overview.
 
 ## v1.3
 
 Major new features
 
-* Dramatically reduced overhead by using dependency lookup cache more efficiently. After the initial scriptlet-jar-building, `kscript` runs with almost **zero overhead** now (fixes  [#4](https://github.com/holgerbrandl/kscript/issues/4))
-* Dependencies can now declared in multiple lines for better readability (fixes [#2](https://github.com/holgerbrandl/kscript/issues/2))
+* Dramatically reduced overhead by using dependency lookup cache more efficiently. After the initial
+  scriptlet-jar-building, `kscript` runs with almost **zero overhead** now (
+  fixes  [#4](https://github.com/holgerbrandl/kscript/issues/4))
+* Dependencies can now declared in multiple lines for better readability (
+  fixes [#2](https://github.com/holgerbrandl/kscript/issues/2))
 * Automatic inclusion of support library for one-liners (fixes [#19](https://github.com/holgerbrandl/kscript/issues/19))
-* Direct script arguments `kscript 'println("hello kotlin")'` (fixes [#18](https://github.com/holgerbrandl/kscript/issues/18))
+* Direct script arguments `kscript 'println("hello kotlin")'` (
+  fixes [#18](https://github.com/holgerbrandl/kscript/issues/18))
 * More robust dependency resolution with more informative error messages
 
-
 Support API improvements
-* Kotlin DocOpt helpers to build CLIs ([example](https://github.com/holgerbrandl/kscript-support-api/blob/master/src/test/kotlin/kscript/test/DocOptTest.kt))
-* New [utilities](https://github.com/holgerbrandl/kscript-support-api/blob/master/src/main/kotlin/kscript/StreamUtil.kt) to automatically resolve arguments files and stdin to `Sequence<String` for by-line processing
+
+* Kotlin DocOpt helpers to build
+  CLIs ([example](https://github.com/holgerbrandl/kscript-support-api/blob/master/src/test/kotlin/kscript/test/DocOptTest.kt))
+* New [utilities](https://github.com/holgerbrandl/kscript-support-api/blob/master/src/main/kotlin/kscript/StreamUtil.kt)
+  to automatically resolve arguments files and stdin to `Sequence<String` for by-line processing
 
 Other changes
-* Allow dependencies to be declared in multiple lines prefixed by `//DEPS` (fixes [#2](https://github.com/holgerbrandl/kscript/issues/2))
-* To ensure long-term stability of `kscript` we've added a suite of [unit tests](test/TestsReadme.md). The repository tested continuously by [Travis CI](https://travis-ci.org/holgerbrandl/kscript)
+
+* Allow dependencies to be declared in multiple lines prefixed by `//DEPS` (
+  fixes [#2](https://github.com/holgerbrandl/kscript/issues/2))
+* To ensure long-term stability of `kscript` we've added a suite of [unit tests](test/TestsReadme.md). The repository
+  tested continuously by [Travis CI](https://travis-ci.org/holgerbrandl/kscript)
 * Cache directory is now `~/.kscript`
 * More heuristics to guess `KOTLIN_HOME`
 * Cache cleanup `--clear-cache` now applies to jars, scripts, urls, and cached dependency lookups
 
-
-## v1.2 
+## v1.2
 
 * Fixed compatibility with [Kotlin v1.1](https://kotlinlang.org/docs/reference/whatsnew11.html)
- (fixes [#15](https://github.com/holgerbrandl/kscript/issues/15))
-* Added `-i` to dump interactive console command incl deps (fixes [#10](https://github.com/holgerbrandl/kscript/issues/10))
+  (fixes [#15](https://github.com/holgerbrandl/kscript/issues/15))
+* Added `-i` to dump interactive console command incl deps (
+  fixes [#10](https://github.com/holgerbrandl/kscript/issues/10))
 * Compile jars should go to TEMP (fixes [#13](https://github.com/holgerbrandl/kscript/issues/13))
-* started test-suite 
+* started test-suite
 
 ## v1.1
 
diff --git a/README.md b/README.md
index c52c6ba9..feea7306 100644
--- a/README.md
+++ b/README.md
@@ -1,25 +1,33 @@
 # kscript - Having fun with Kotlin scripting
 
-
 [![GitHub release](https://img.shields.io/github/release/holgerbrandl/kscript.svg)](https://github.com/holgerbrandl/kscript/releases)
-[![Build Status](https://github.com/holgerbrandl/krangl/workflows/build/badge.svg)](https://github.com/holgerbrandl/krangl/actions?query=workflow%3Abuild) 
+[![Build Status](https://github.com/holgerbrandl/kscript/workflows/build/badge.svg)](https://github.com/holgerbrandl/kscript/actions/workflows/build.yml)
 [![Gitter](https://badges.gitter.im/holgerbrandl/kscript.svg)](https://gitter.im/holgerbrandl/kscript?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
 Enhanced scripting support for [Kotlin](https://kotlinlang.org/) on *nix-based systems.
 
-Kotlin has some built-in support for scripting already but it is not yet feature-rich enough to be a viable alternative in the shell.
+Kotlin has some built-in support for scripting already but it is not yet feature-rich enough to be a viable alternative
+in the shell.
 
 In particular this wrapper around `kotlinc` adds
+
 * Compiled script caching (using md5 checksums)
-* Dependency declarations using gradle-style resource locators and automatic dependency resolution with [jcabi-aether](https://github.com/jcabi/jcabi-aether)
+* Dependency declarations using gradle-style resource locators and automatic dependency resolution
+  with [jcabi-aether](https://github.com/jcabi/jcabi-aether)
 * More options to provide scripts including interpreter mode, reading from stdin, local files or URLs
 * Embedded configuration for Kotlin runtime options
 * Support library to ease the writing of Kotlin scriptlets
 * Deploy scripts as stand-alone binaries
 
-Taken all these features together, `kscript` provides an easy-to-use, very flexible, and almost zero-overhead solution to write self-contained mini-applications with Kotlin.
+Taken all these features together, `kscript` provides an easy-to-use, very flexible, and almost zero-overhead solution
+to write self-contained mini-applications with Kotlin.
 
-**Good News**: Kotlin [v1.4](https://kotlinlang.org/docs/reference/whatsnew14.html#scripting-and-repl) finally ships with a much improved - and needed - scripting integration. See [here](https://github.com/Kotlin/kotlin-script-examples/blob/master/jvm/main-kts/MainKts.md) for examples and documentation. Still, we think that `kscript` has various benefits compared this new platform-bundled improved toolstack, so we'll plan to support `kscript` until the kotlin platform will ship with an even more rich and versatile kotlin scripting interpreter.
+**Good News**: Kotlin [v1.4](https://kotlinlang.org/docs/reference/whatsnew14.html#scripting-and-repl) finally ships
+with a much improved - and needed - scripting integration.
+See [here](https://github.com/Kotlin/kotlin-script-examples/blob/master/jvm/main-kts/MainKts.md) for examples and
+documentation. Still, we think that `kscript` has various benefits compared this new platform-bundled improved
+toolstack, so we'll plan to support `kscript` until the kotlin platform will ship with an even more rich and versatile
+kotlin scripting interpreter.
 
 ---
 **[`kscript` presentation from KotlinConf2017!](https://holgerbrandl.github.io/kscript_kotlinconf_2017/kscript_kotlinconf.html)**
@@ -41,11 +49,13 @@ Taken all these features together, `kscript` provides an easy-to-use, very flexi
 - [How to contribute?](#how-to-contribute)
 - [Acknowledgements](#acknowledgements)
 
-
 Installation
 ------------
 
-To use `kscript` just Kotlin and Maven are required. To [install Kotlin](https://kotlinlang.org/docs/tutorials/command-line.html) we recommend [sdkman](http://sdkman.io/install):
+To use `kscript` just Kotlin and Maven are required.
+To [install Kotlin](https://kotlinlang.org/docs/tutorials/command-line.html) we
+recommend [sdkman](http://sdkman.io/install):
+
 ```
 curl -s "https://get.sdkman.io" | bash     # install sdkman
 source "$HOME/.sdkman/bin/sdkman-init.sh"  # add sdkman to PATH
@@ -54,12 +64,13 @@ sdk install kotlin                         # install Kotlin
 ```
 
 Once Kotlin is ready, you can install `kscript` with
+
 ```
 sdk install kscript
 ```
 
-
 To test your installation simply run
+
 ```bash
 kscript --help
 ```
@@ -84,22 +95,29 @@ To use a script file outside of the container as input, you could do
 docker run -i holgerbrandl/kscript - < script.kts
 ```
 
-This will make `kscript` read the code from stdin while piping the file. Beware that the -i flag is needed to have stdout redirected outside the container.
+This will make `kscript` read the code from stdin while piping the file. Beware that the -i flag is needed to have
+stdout redirected outside the container.
 
-Please note, that currently `@Include` are not supported when using a dockerized kscript. Also, any resource outside the container context may not be resolved correctly. To overcome this limitation, you could use for instance [bind mounts](https://docs.docker.com/storage/bind-mounts/).
+Please note, that currently `@Include` are not supported when using a dockerized kscript. Also, any resource outside the
+container context may not be resolved correctly. To overcome this limitation, you could use for
+instance [bind mounts](https://docs.docker.com/storage/bind-mounts/).
 
 #### Installation without `sdkman`
 
-If you have Kotlin and Maven already and you would like to install the latest `kscript` release without using `sdkman` you can do so by unzipping the [latest ](https://github.com/holgerbrandl/kscript/releases/latest) binary release. Don't forget to update your `$PATH` accordingly.
+If you have Kotlin and Maven already and you would like to install the latest `kscript` release without using `sdkman`
+you can do so by unzipping the [latest ](https://github.com/holgerbrandl/kscript/releases/latest) binary release. Don't
+forget to update your `$PATH` accordingly.
 
 #### Installation with Homebrew
 
 On MacOS you can install `kscript` also with [Homebrew](https://brew.sh/)
+
 ```bash
 brew install holgerbrandl/tap/kscript
 ```
 
 To upgrade to latest version
+
 ```bash
 brew update
 brew upgrade holgerbrandl/tap/kscript
@@ -107,7 +125,10 @@ brew upgrade holgerbrandl/tap/kscript
 
 #### Installation on Arch Linux
 
-On Arch Linux, `kscript` is available through the [Arch Linux User repository (AUR)](https://aur.archlinux.org/packages/kscript/). Use your favorite [AUR helper](https://wiki.archlinux.org/index.php/AUR_helpers) to install, e.g. `yay`:
+On Arch Linux, `kscript` is available through
+the [Arch Linux User repository (AUR)](https://aur.archlinux.org/packages/kscript/). Use your
+favorite [AUR helper](https://wiki.archlinux.org/index.php/AUR_helpers) to install, e.g. `yay`:
+
 ```shell
 yay -S kscript
 ```
@@ -115,6 +136,7 @@ yay -S kscript
 #### Build it yourself
 
 To build `kscript` yourself, simply clone the repo and do
+
 ```bash
 ./gradlew assemble
 
@@ -126,8 +148,8 @@ To build `kscript` yourself, simply clone the repo and do
 
 The main mode of operation is `kscript <script>`.
 
-The `<script>` can be a Kotlin `*.kts` script file , a script URL, `-` for stdin, a process substitution file handle, a `*.kt` source file with a main method, or some kotlin code.
-
+The `<script>` can be a Kotlin `*.kts` script file , a script URL, `-` for stdin, a process substitution file handle,
+a `*.kt` source file with a main method, or some kotlin code.
 
 ### Interpreter Usage
 
@@ -144,15 +166,15 @@ for (arg in args) {
 
 ### Inlined Usage
 
-
-To use `kscript` in a workflow without creating an additional script file, you can also use one of its supported modes for _inlined usage_. The following modes are supported:
+To use `kscript` in a workflow without creating an additional script file, you can also use one of its supported modes
+for _inlined usage_. The following modes are supported:
 
 * Directly provide a Kotlin scriptlet as argument
+
 ```{bash}
 kscript 'println("hello world")'
 ```
 
-
 * Pipe a Kotlin snippet into `kscript` and instruct it to read from `stdin` by using `-` as script argument
 
 ```{bash}
@@ -161,8 +183,8 @@ println("Hello Kotlin.")
 ' |  kscript -
 ```
 
-
-* Using `heredoc` (preferred solution for inlining) which gives you some more flexibility to also use single quotes in your script:
+* Using `heredoc` (preferred solution for inlining) which gives you some more flexibility to also use single quotes in
+  your script:
 
 ```{bash}
 kscript - <<"EOF"
@@ -171,6 +193,7 @@ EOF
 ```
 
 * Since the piped content is considered as a regular script it can also have dependencies
+
 ```{bash}
 kscript - <<"EOF"
 //DEPS com.offbytwo:docopt:0.6.0.20150202 log4j:log4j:1.2.14
@@ -182,32 +205,42 @@ println("hello again")
 EOF
 ```
 
-* Finally (for sake of completeness), it also works with process substitution and for sure you can always provide additional arguments (exposed as `args : Array<String>` within the script)
+* Finally (for sake of completeness), it also works with process substitution and for sure you can always provide
+  additional arguments (exposed as `args : Array<String>` within the script)
+
 ```{bash}
 kscript <(echo 'println("k-onliner")') arg1 arg2 arg3 
 ```
 
-Inlined _kscripts_ are also cached based on `md5` checksum, so running the same snippet again will use a cached jar (sitting in `~/.kscript`).
-
+Inlined _kscripts_ are also cached based on `md5` checksum, so running the same snippet again will use a cached jar (
+sitting in `~/.kscript`).
 
 ### URL usage
 
-To support remote scriplet repositories, `kscript` can also work with URLs. Consider the following [hello-world-gist-scriptlet](https://github.com/holgerbrandl/kscript/blob/master/examples/url_example.kts) which is hosted on github (but any URL would work). To run it locally as a tool simply refer to it (here using the shortened [raw-URL](https://raw.githubusercontent.com/holgerbrandl/kscript/master/examples/url_example.kts) of the script for better readability)
+To support remote scriplet repositories, `kscript` can also work with URLs. Consider the
+following [hello-world-gist-scriptlet](https://github.com/holgerbrandl/kscript/blob/master/examples/url_example.kts)
+which is hosted on github (but any URL would work). To run it locally as a tool simply refer to it (here using the
+shortened [raw-URL](https://raw.githubusercontent.com/holgerbrandl/kscript/master/examples/url_example.kts) of the
+script for better readability)
 
 ```bash
 kscript https://git.io/v1cG6 my argu ments 
 ```
 
 To streamline the usage, the first part could be even aliased:
+
 ```bash
 alias hello_kscript="kscript https://git.io/v1cG6"
 hello_kscript my argu ments
 ```
+
 Via this mechanism, `kscript` allows for easy integration of remotely hosted (mini) programs into data workflows.
 
-URL-scripts are cached locally to speed up processing, and `kscript --clear-cache` can be used to wipe the cache if needed.
+URL-scripts are cached locally to speed up processing, and `kscript --clear-cache` can be used to wipe the cache if
+needed.
 
-See this [blogpost](http://holgerbrandl.github.io/kotlin/2016/12/02/mini_programs_with_kotlin.html) for a more extensive overview about URL support in `kscript`.
+See this [blogpost](http://holgerbrandl.github.io/kotlin/2016/12/02/mini_programs_with_kotlin.html) for a more extensive
+overview about URL support in `kscript`.
 
 Script Configuration
 --------------------
@@ -219,10 +252,10 @@ The following directives supported by `kscript` to configure scripts:
 * `//INCLUDE` to source kotlin files into the script
 * `//ENTRY` to declare the application entrypoint for kotlin `*.kt` applications
 
-
 ### Declare dependencies with `//DEPS`
 
-To specify dependencies simply use gradle-style locators. Here's an example using [docopt](https://github.com/docopt/docopt.java) and [log4j](http://logging.apache.org/log4j/2.x/)
+To specify dependencies simply use gradle-style locators. Here's an example
+using [docopt](https://github.com/docopt/docopt.java) and [log4j](http://logging.apache.org/log4j/2.x/)
 
 ```kotlin
 #!/usr/bin/env kscript
@@ -231,7 +264,6 @@ To specify dependencies simply use gradle-style locators. Here's an example usin
 import org.docopt.Docopt
 import java.util.*
 
-
 val usage = """
 Use this cool tool to do cool stuff
 Usage: cooltool.kts [options] <igenome> <fastq_files>...
@@ -247,11 +279,14 @@ println("Hello from Kotlin!")
 println("Parsed script arguments are: \n" + doArgs)
 ```
 
-`kscript` will read dependencies from all lines in a script that start with `//DEPS` (if any). Multiple dependencies can be split by comma, space or semicolon.
+`kscript` will read dependencies from all lines in a script that start with `//DEPS` (if any). Multiple dependencies can
+be split by comma, space or semicolon.
 
 ### Configure the runtime  with `//KOTLIN_OPTS`
 
-`kscript` allows to provide a `//KOTLIN_OPTS` directive followed by parameters passed on to `kotlin` similar to how dependencies are defined:
+`kscript` allows to provide a `//KOTLIN_OPTS` directive followed by parameters passed on to `kotlin` similar to how
+dependencies are defined:
+
 ```kotlin
 #!/usr/bin/env kscript
 //KOTLIN_OPTS -J-Xmx5g  -J-server
@@ -263,7 +298,8 @@ Note: Similar to the runtime you can also tweak the compile step by providing `/
 
 ### Ease prototyping with `//INCLUDE`
 
-`kscript` supports an `//INCLUDE` directive to directly include other source files without prior compilation. Absolute and relative paths, as well as URLs are supported. Example:
+`kscript` supports an `//INCLUDE` directive to directly include other source files without prior compilation. Absolute
+and relative paths, as well as URLs are supported. Example:
 
 ```kotlin
 //utils.kt
@@ -283,14 +319,15 @@ Which can be now used using the `//INCLUDE` directive with
 val robustMean = listOf(1.3, 42.3, 7.).median()
 println(robustMean)
 ```
-The argument can be an URL, absolute or relative file path. Note that URLs used in include directives are cached locally to speed up processing, that is `kscript` won't fetch URLs again unless the user actively clears the cache with `kscript --clear-cache`.
 
-For more examples see [here](test/resources/includes/include_variations.kts).
+The argument can be an URL, absolute or relative file path. Note that URLs used in include directives are cached locally
+to speed up processing, that is `kscript` won't fetch URLs again unless the user actively clears the cache
+with `kscript --clear-cache`.
 
+For more examples see [here](test/resources/includes/include_variations.kts).
 
 ### Use `//ENTRY` to run applications with `main` method
 
-
 `kscript` also supports running regular Kotlin `kt` files.
 
 Example: `./examples/Foo.kt`:
@@ -300,9 +337,10 @@ package examples
 
 //ENTRY examples.Bar
 
-class Bar{
+class Bar {
     companion object {
-        @JvmStatic fun main(args: Array<String>) {
+        @JvmStatic
+        fun main(args: Array<String>) {
             println("Foo was called")
         }
     }
@@ -315,7 +353,6 @@ To run top-level main instead we would use `//ENTRY examples.FooKt`
 
 The latter is the default for `kt` files and could be omitted
 
-
 ### Annotation driven script configuration
 
 Using annotations instead of comment directives to configure scripts is cleaner and allow for better tooling.
@@ -328,23 +365,25 @@ Using annotations instead of comment directives to configure scripts is cleaner
 //DEPS com.github.holgerbrandl:kutils:0.12
 ```
 
- To do so `kscript` supports [annotations](https://github.com/holgerbrandl/kscript-annotations) to be used instead of comment directives:
+To do so `kscript` supports [annotations](https://github.com/holgerbrandl/kscript-annotations) to be used instead of
+comment directives:
+
 ```kotlin
 #!/usr/bin/env kscript
 
 // Declare dependencies
-@file:DependsOn("com.github.holgerbrandl:kutils:0.12")
-@file:DependsOn("com.beust:klaxon:0.24", "com.github.kittinunf.fuel:fuel:2.3.1")
-
+@file:DependsOn("com.github.holgerbrandl:kutils:0.12") @file:DependsOn(
+    "com.beust:klaxon:0.24",
+    "com.github.kittinunf.fuel:fuel:2.3.1"
+)
 
 // To use a custom maven repository you can declare it with
-@file:MavenRepository("imagej-releases","http://maven.imagej.net/content/repositories/releases" )
+@file:MavenRepository("imagej-releases", "http://maven.imagej.net/content/repositories/releases")
 
 // For compatibility with https://github.com/ligee/kotlin-jupyter kscript supports also
 @file:DependsOnMaven("net.clearvolume:cleargl:2.0.1")
 // Note that for compatibility reasons, only one locator argument is allowed for @DependsOnMaven
 
-
 // also protected artifact repositories are supported, see <https://github.com/holgerbrandl/kscript/blob/master/test/TestsReadme.md#manual-testing>
 // @file:MavenRepository("my-art", "http://localhost:8081/artifactory/authenticated_repo", user="auth_user", password="password")
 // You can use environment variables for user and password when string surrounded by double {} brackets 
@@ -355,37 +394,40 @@ Using annotations instead of comment directives to configure scripts is cleaner
 // Include helper scripts without deployment or prior compilation
 @file:Include("util.kt")
 
-
 // Define kotlin options
-@file:KotlinOpts("-J-Xmx5g")
-@file:KotlinOpts("-J-server")
-@file:CompilerOpts("-jvm-target 1.8")
+@file:KotlinOpts("-J-Xmx5g") @file:KotlinOpts("-J-server") @file:CompilerOpts("-jvm-target 1.8")
 
 // declare application entry point (applies on for kt-files)
-@file:EntryPoint("Foo.bar") 
+@file:EntryPoint("Foo.bar")
 
 print("1+1")
 ```
 
-To enable the use of these annotations in Intellij, the user must add the following artifact to the project dependencies:
+To enable the use of these annotations in Intellij, the user must add the following artifact to the project
+dependencies:
+
 ```
 com.github.holgerbrandl:kscript-annotations:1.2
 ```
 
-`kscript` will automatically detect an annotation-driven script, and if so will declare a dependency on this artifact internally.
-
-Note, that if a script is located in a package other than the root package, you need to import the annotations with (e.g. `import DependsOn`).
+`kscript` will automatically detect an annotation-driven script, and if so will declare a dependency on this artifact
+internally.
 
+Note, that if a script is located in a package other than the root package, you need to import the annotations with (
+e.g. `import DependsOn`).
 
 ## Text Processing Mode
 
-`kscript` can be used as a speedier and more flexible substitute for built-in terminal text tools such as `awk` or `sed`. Its text processing mode can be enabled with `-t` or `--text`. If so, `kscript` will
+`kscript` can be used as a speedier and more flexible substitute for built-in terminal text tools such as `awk` or `sed`
+. Its text processing mode can be enabled with `-t` or `--text`. If so, `kscript` will
 
-* Declare `com.github.holgerbrandl:kscript-support-api:1.2.5` as dependency for the script. This [support library](https://github.com/holgerbrandl/kscript-support-api) eases the writing of Kotlin scriptlets for text-processing. It includes solutions to common use-cases like argument parsing, data streaming, IO utilities, and various iterators to streamline the writing of scriptlets for text processing.
+* Declare `com.github.holgerbrandl:kscript-support-api:1.2.5` as dependency for the script.
+  This [support library](https://github.com/holgerbrandl/kscript-support-api) eases the writing of Kotlin scriptlets for
+  text-processing. It includes solutions to common use-cases like argument parsing, data streaming, IO utilities, and
+  various iterators to streamline the writing of scriptlets for text processing.
 * Import the `kscript.*` namespace
-* Define variable `val lines = kscript.text.resolveArgFile(args)` which returns an iterator over the lines in the first input argument of the script, or the standard input if no file arguments are provided to the script
-
-
+* Define variable `val lines = kscript.text.resolveArgFile(args)` which returns an iterator over the lines in the first
+  input argument of the script, or the standard input if no file arguments are provided to the script
 
 This allows to to replace `awk`ward constructs (or `sed` or`perl`) with _kotlinesque_ solutions such as
 
@@ -397,16 +439,22 @@ cat some_file | kscript -t 'lines
 '
 ```
 
-In this example, the extension method [`Iterable<String>.print()`](https://github.com/holgerbrandl/kscript-support-api/blob/master/src/main/kotlin/kscript/text/StreamUtil.kt#L34) to print the lines to stdout comes from the support API. The rest is stdlib Kotlin.
+In this example, the extension
+method [`Iterable<String>.print()`](https://github.com/holgerbrandl/kscript-support-api/blob/master/src/main/kotlin/kscript/text/StreamUtil.kt#L34)
+to print the lines to stdout comes from the support API. The rest is stdlib Kotlin.
 
- For more examples using the support library see this [blog post](http://holgerbrandl.github.io/kotlin/2017/05/08/kscript_as_awk_substitute.html).
+For more examples using the support library see
+this [blog post](http://holgerbrandl.github.io/kotlin/2017/05/08/kscript_as_awk_substitute.html).
 
 Treat yourself a REPL with `--interactive`
 ------------------------------------------
 
-To create an interactive kotlin shell (aka [REPL](https://kotlinlang.org/docs/tutorials/command-line.html#running-the-repl)) with all script dependencies added to the classpath you can use `--interactive`.
+To create an interactive kotlin shell (
+aka [REPL](https://kotlinlang.org/docs/tutorials/command-line.html#running-the-repl)) with all script dependencies added
+to the classpath you can use `--interactive`.
 
 For example, let's assume the following short script, named `CountRecords.kts`
+
 ```kotlin
 #!/usr/bin/env kscript
 @file:DependsOn("com.github.holgerbrandl:kutils:0.12")
@@ -427,7 +475,9 @@ To build a REPL that has the declared artifact in its classpath, we can just do
 ```bash
 kscript --interactive CountRecords.kts
 ```
+
 which will bring up the classpath-enhanced REPL:
+
 ```
 Creating REPL from CountRecords.kts
 Welcome to Kotlin version 1.1.51 (JRE 1.8.0_151-b12)
@@ -438,16 +488,22 @@ Welcome to Kotlin version 1.1.51 (JRE 1.8.0_151-b12)
 Boostrap IDEA from a `kscript`let
 -----------------------------------
 
-Artifacts and versions will differ between scripts, so it is hard to maintain them all in a single project. To nevertheless provide optimal tooling when scripting with Kotlin `kscript` allows to create temporary projects for `<script>` arguments. .
+Artifacts and versions will differ between scripts, so it is hard to maintain them all in a single project. To
+nevertheless provide optimal tooling when scripting with Kotlin `kscript` allows to create temporary projects
+for `<script>` arguments. .
 
 ```bash
 kscript --idea CountRecords.kts
 ```
-This will open [IntelliJ IDEA](https://www.jetbrains.com/idea/) with a minimalistic project containing just your (1) `<script>` and (2) a generated `gradle.build` file:
+
+This will open [IntelliJ IDEA](https://www.jetbrains.com/idea/) with a minimalistic project containing just your (
+1) `<script>` and (2) a generated `gradle.build` file:
 
 ![](misc/readme_images/minus_idea.png)
 
-This assumes that you have the Intellij IDEA command line launcher `idea` in your `PATH`. It can be created in IntelliJ under `Tools -> Create Command-line Launcher` or  you can set the command used to launch your intellij as `KSCRIPT_IDEA_COMMAND` env property
+This assumes that you have the Intellij IDEA command line launcher `idea` in your `PATH`. It can be created in IntelliJ
+under `Tools -> Create Command-line Launcher` or you can set the command used to launch your intellij
+as `KSCRIPT_IDEA_COMMAND` env property
 
 Deploy scripts as standalone binaries
 --------------------------------------
@@ -459,8 +515,8 @@ kscript --package some_script.kts
 ./some_script --arg u ments
 ```
 
-The created binary will contain a compiled copy of the script, as well as all declared dependencies (fatjar). Also runtime jvm parameters declared via `@file:KotlinOpts` are used to spin up the JVM.
-
+The created binary will contain a compiled copy of the script, as well as all declared dependencies (fatjar). Also
+runtime jvm parameters declared via `@file:KotlinOpts` are used to spin up the JVM.
 
 Just `java` is required to run these binaries.
 
@@ -468,16 +524,21 @@ Just `java` is required to run these binaries.
 Embed kscript installer within your script
 --------------------------------------
 
- To make a script automatically [install kscript](#installation) and its dependencies on first run if necessary, run:
+To make a script automatically [install kscript](#installation) and its dependencies on first run if necessary, run:
 
  ```bash
 kscript --add-bootstrap-header some_script.kts
 ```
 
-Now `some_script.kts` can be shared and run directly on any other machine that has `bash`, without having to go through the [Installation](#installation) steps first.
+Now `some_script.kts` can be shared and run directly on any other machine that has `bash`, without having to go through
+the [Installation](#installation) steps first.
 
-Note that unlike the [`--package` option](#deploy-scripts-as-standalone-binaries) this doesn't produce a separate file, allowing the distributed script to be read and modified(including with [`kscript --idea`](#boostrap-idea-from-a-kscriptlet)) similar to what you might expect with bash/python/ruby scripts.
-On the other hand this doesn't embed dependencies within the script("fat jar"), so internet connection may be required on its first run.
+Note that unlike the [`--package` option](#deploy-scripts-as-standalone-binaries) this doesn't produce a separate file,
+allowing the distributed script to be read and modified(including
+with [`kscript --idea`](#boostrap-idea-from-a-kscriptlet)) similar to what you might expect with bash/python/ruby
+scripts.
+On the other hand this doesn't embed dependencies within the script("fat jar"), so internet connection may be required
+on its first run.
 
 
 FAQ
@@ -485,53 +546,65 @@ FAQ
 
 ### How to edit kscript in VS Code?
 
-See https://magnusgunnarsson.se/offentlig/kscript-in-visual-studio-code-vsc/ for a walkthrough and the required editor configuration.
+See https://magnusgunnarsson.se/offentlig/kscript-in-visual-studio-code-vsc/ for a walkthrough and the required editor
+configuration.
 
 ### Why is `kscript` not calling the main method in my `.kts` script?
 
-There is [no need](https://kotlinlang.org/docs/tutorials/command-line.html#using-the-command-line-to-run-scripts) for a `main` method in a Kotlin script. Kotlin `*.kts` scripts can be more simplistic compared to more common kotlin `*.kt` source files. The former work without a `main` method by directly running the provided code from top to bottom. E.g.
+There is [no need](https://kotlinlang.org/docs/tutorials/command-line.html#using-the-command-line-to-run-scripts) for
+a `main` method in a Kotlin script. Kotlin `*.kts` scripts can be more simplistic compared to more common kotlin `*.kt`
+source files. The former work without a `main` method by directly running the provided code from top to bottom. E.g.
+
 ```
 print("hello kotlin!")
 ```
-is a valid Kotlin `kts` script. Plain and simple, no `main`, no `companion`, just a few bits of code.
 
+is a valid Kotlin `kts` script. Plain and simple, no `main`, no `companion`, just a few bits of code.
 
 ### Does `kscript` also work for regular kotlin `.kt` source files with a `main` as entry point?
 
-Yes, (since v1.6) you can run kotlin source files through `kscript`. By default it will assume a top-level `main` method as entry-point.
-
-However in case you're using a companion object to declare the entry point, you need to indicate this via the `//ENTRY`/`@file:Entry` directive:
+Yes, (since v1.6) you can run kotlin source files through `kscript`. By default it will assume a top-level `main` method
+as entry-point.
 
+However in case you're using a companion object to declare the entry point, you need to indicate this via the `//ENTRY`
+/`@file:Entry` directive:
 
 ### Why does it fail to read my script file when using cygwin?
 
-In order to use cygwin you need to use windows paths to provide your scripts. You can map cygwin paths using `cygpath`. Example
+In order to use cygwin you need to use windows paths to provide your scripts. You can map cygwin paths using `cygpath`.
+Example
+
 ```bash
 kscript $(cygpath -w /cygdrive/z/some/path/my_script.kts)
 ```
 
 ### What are performance and resource usage difference between scripting with kotlin and python?
 
-Kotlin is a compiled language, so there is a compilation overhead when you run a script/application written in Kotlin for the first time.
+Kotlin is a compiled language, so there is a compilation overhead when you run a script/application written in Kotlin
+for the first time.
 
-Kotlin runs (mainly) on the JVM which needs some time (~200ms) to start up. In contrast, the python interpreter has close to zero warmup time.
+Kotlin runs (mainly) on the JVM which needs some time (~200ms) to start up. In contrast, the python interpreter has
+close to zero warmup time.
 
-I think there is a consensus that JVM programs execute much faster than python equivalents. Still, python might be faster depending on your specific usecase. Also, with kotlin-native becoming more mature, you could compile into native binaries directly, which should bring it close to C/C++ performance.
+I think there is a consensus that JVM programs execute much faster than python equivalents. Still, python might be
+faster depending on your specific usecase. Also, with kotlin-native becoming more mature, you could compile into native
+binaries directly, which should bring it close to C/C++ performance.
 
 Main motivations for using Kotlin over Python for scripting and development are
-* Kotlin is the better designed, more fluent language with much better tooling around it
-* The JVM dependency ecosystem allows for strict versioning. No more messing around with virtualenv, e.g. to run a short 10liner against a specific version of numpy.
 
+* Kotlin is the better designed, more fluent language with much better tooling around it
+* The JVM dependency ecosystem allows for strict versioning. No more messing around with virtualenv, e.g. to run a short
+  10liner against a specific version of numpy.
 
 ### Does kscript work with java?
 
-The only language supported by `kscript` is kotlin. For a similar approach centering around Java scripting see [jbang](https://github.com/maxandersen/jbang). 
-
-
+The only language supported by `kscript` is kotlin. For a similar approach centering around Java scripting
+see [jbang](https://github.com/maxandersen/jbang).
 
 ### Can I use custom artifact repositories?
 
-Yes, via the `@MavenRepository` annotation. See [annotations section](#annotation-driven-script-configuration) or [custom_mvn_repo_annot](test/resources/custom_mvn_repo_annot.kts) for a complete example
+Yes, via the `@MavenRepository` annotation. See [annotations section](#annotation-driven-script-configuration)
+or [custom_mvn_repo_annot](test/resources/custom_mvn_repo_annot.kts) for a complete example
 
 
 Support
@@ -546,32 +619,40 @@ How to contribute?
 
 We always welcome pull requests and trouble tickets. :-)
 
-
 Help to spread the word. Great community articles about `kscript` include
+
 * [Type-safety in the shell with kscript](https://medium.com/@OhadShai/type-safety-in-the-shell-with-kscript-7dd40d022537)
 * [Using Kotlin kscript for Preprocessing Data](https://medium.com/@kenkyee/using-kotlin-kscript-for-preprocessing-data-1dbff4eae292)
 * [kscript as substitute for awk](https://holgerbrandl.github.io/kotlin/2017/05/08/kscript_as_awk_substitute.html)
-* [A complete backend with Kotlin and your favourite text-editor](https://hackernoon.com/a-complete-backend-only-with-kotlin-and-your-favourite-text-editor-582b4528688) -using kscript
+* [A complete backend with Kotlin and your favourite text-editor](https://hackernoon.com/a-complete-backend-only-with-kotlin-and-your-favourite-text-editor-582b4528688)
+  -using kscript
 
-You could also show your support by upvoting `kscript` here on github, or by voting for issues in Intellij IDEA which impact `kscript`ing. Here are our top 2 tickets/annoyances that we would love to see fixed:
+You could also show your support by upvoting `kscript` here on github, or by voting for issues in Intellij IDEA which
+impact `kscript`ing. Here are our top 2 tickets/annoyances that we would love to see fixed:
 
 * [KT-13347](https://youtrack.jetbrains.com/issue/KT-13347) Good code is red in injected kotlin language snippets
 
-
 To allow for more interactive script development, you could also vote/comment on the most annoying REPL issues.
 
-* [KT-24789](https://youtrack.jetbrains.net/issue/KT-24789) "Unresolved reference" when running a script which is a symlink to a script outside of source roots
+* [KT-24789](https://youtrack.jetbrains.net/issue/KT-24789) "Unresolved reference" when running a script which is a
+  symlink to a script outside of source roots
 * [KT-12583](https://youtrack.jetbrains.com/issue/KT-12583) IDE REPL should run in project root directory
 * [KT-11409](https://youtrack.jetbrains.com/issue/KT-11409) Allow to "Send Selection To Kotlin Console"
 
-
 Acknowledgements
 ----------------
 
 The initial version of `kscript` was kindly contributed by [Oscar Gonzalez](https://github.com/oskargb).
 
-Special thanks to [Ilan Pillemer](https://github.com/ilanpillemer), [Andrey Mischenko ](https://github.com/gildor), [Stephen Byrne](https://github.com/stephenbyrne-mfj), [Eugene Susla](https://github.com/EugeneSusla), [Eli Hart](https://github.com/elihart), [Hwijae Lee](https://github.com/hj-lee) and [oshai](https://github.com/oshai) for [contributing](https://github.com/holgerbrandl/kscript/graphs/contributors) PRs to this repo.
+Special thanks to [Ilan Pillemer](https://github.com/ilanpillemer), [Andrey Mischenko ](https://github.com/gildor)
+, [Stephen Byrne](https://github.com/stephenbyrne-mfj), [Eugene Susla](https://github.com/EugeneSusla)
+, [Eli Hart](https://github.com/elihart), [Hwijae Lee](https://github.com/hj-lee) and [oshai](https://github.com/oshai)
+for [contributing](https://github.com/holgerbrandl/kscript/graphs/contributors) PRs to this repo.
+
+Thanks also to the [Scionics Computer Innovation GmbH](https://www.scionics.com/) and
+the [MPI-CBG](http://www.mpi-cbg.de) for supporting this project.
 
-Thanks also to the [Scionics Computer Innovation GmbH](https://www.scionics.com/) and the [MPI-CBG](http://www.mpi-cbg.de) for supporting this project.
+Version 3.1 to 4.0 rewrite by [Marcin Kuszczak](https://github.com/aartiPl/)
 
-`kscript` was inspired by [kotlin-script](https://github.com/andrewoma/kotlin-script) which is another great way (now deprecated) to do scripting in Kotlin.
+`kscript` was inspired by [kotlin-script](https://github.com/andrewoma/kotlin-script) which is another great way (now
+deprecated) to do scripting in Kotlin.
diff --git a/test/resources/compiler_opts_with_includes.sh b/test/resources/compiler_opts_with_includes.sh
index df0dcf20..901de12d 100644
--- a/test/resources/compiler_opts_with_includes.sh
+++ b/test/resources/compiler_opts_with_includes.sh
@@ -1,8 +1,8 @@
 ## Prevent regressions of https://github.com/holgerbrandl/kscript/issues/173
 
-echo "fun foo() = 42" > compiler_opts_with_includes_dep.kts
+echo "fun foo() = 42" > $KSCRIPT_TEST_DIR/compiler_opts_with_includes_dep.kts
 
-cat <<"EOF" > compiler_opts_with_includes_master.kt
+cat <<"EOF" > $KSCRIPT_TEST_DIR/compiler_opts_with_includes_master.kt
 @file:CompilerOpts("-jvm-target 1.8")
 @file:Include("compiler_opts_with_includes_dep.kts")
 @file:DependsOnMaven("log4j:log4j:1.2.14")
@@ -14,5 +14,4 @@ fun main(args: Array<String>) {
 }
 EOF
 
-kscript compiler_opts_with_includes_master.kt
-
+kscript $KSCRIPT_TEST_DIR/compiler_opts_with_includes_master.kt
diff --git a/test/resources/home_dir_include.sh b/test/resources/home_dir_include.sh
index 9ea0df40..d8c9b362 100644
--- a/test/resources/home_dir_include.sh
+++ b/test/resources/home_dir_include.sh
@@ -3,6 +3,6 @@ echo "fun foo() = 42" > ~/.kscript_home_include.kts
 echo '
 //INCLUDE ~/.kscript_home_include.kts
 println(foo())
-' > home_dir_master.kts
+' > $KSCRIPT_TEST_DIR/home_dir_master.kts
 
-kscript home_dir_master.kts
\ No newline at end of file
+kscript $KSCRIPT_TEST_DIR/home_dir_master.kts
diff --git a/test/resources/local_script_file.sh b/test/resources/local_script_file.sh
index 8c9bb99f..dd0e530e 100644
--- a/test/resources/local_script_file.sh
+++ b/test/resources/local_script_file.sh
@@ -1,3 +1,3 @@
-scriptFile=test_script.kts
+scriptFile=$KSCRIPT_TEST_DIR/test_script.kts
 echo 'println("kscript rocks!")' > ${scriptFile}
-kscript $scriptFile
\ No newline at end of file
+kscript $scriptFile
diff --git a/test/setup_environment.sh b/test/setup_environment.sh
index f3045470..1d66d0b7 100644
--- a/test/setup_environment.sh
+++ b/test/setup_environment.sh
@@ -51,15 +51,26 @@ assert_stderr(){
     assert "( $1 ) 2>&1 >/dev/null" "$2"
 }
 
-# $1 - suite name; $2 - requested suites
+# $1 - suite name; $2... - requested suites
 start_suite() {
-  if [[ "${2}" =~ "${1}" ]] || [[ "${2}" == "ALL" ]]; then
+  PARAM_SUITE="$1"
+  PARAM_REQUESTED_SUITES="${@:2}"
+
+  if [[ "${PARAM_REQUESTED_SUITES}" =~ "${PARAM_SUITE}" ]] || [[ "${PARAM_REQUESTED_SUITES}" == "ALL" ]]; then
     echo
-    echo "Starting '$1' tests:"
+    echo "Starting '$PARAM_SUITE' tests:"
+
+    SUITE_FILE="${PROJECT_DIR}/test/suite/${PARAM_SUITE}.sh"
+    if [[ -f ${SUITE_FILE} ]]; then
+      source ${SUITE_FILE}
+
+      assert_end "$PARAM_SUITE"
+    fi
+
     return 0
   fi
 
-  echo "Skipping '$1' tests..."
+  echo "Skipping '$PARAM_SUITE' tests..."
   return 1
 }
 
diff --git a/test/suite/annotation_driven_configuration.sh b/test/suite/annotation_driven_configuration.sh
new file mode 100644
index 00000000..6f011cf9
--- /dev/null
+++ b/test/suite/annotation_driven_configuration.sh
@@ -0,0 +1,22 @@
+## there are some dependencies which are not jar, but maybe pom, aar,... make sure they work, too
+assert "kscript ${PROJECT_DIR}/test/resources/depends_on_with_type.kts" "getBigDecimal(1L): 1"
+
+# make sure that @file:DependsOn is parsed correctly
+assert "kscript ${PROJECT_DIR}/test/resources/depends_on_annot.kts" "kscript with annotations rocks!"
+
+# make sure that @file:DependsOnMaven is parsed correctly
+assert "kscript ${PROJECT_DIR}/test/resources/depends_on_maven_annot.kts" "kscript with annotations rocks!"
+
+# make sure that dynamic versions are matched properly
+assert "kscript ${PROJECT_DIR}/test/resources/depends_on_dynamic.kts" "dynamic kscript rocks!"
+
+# make sure that @file:MavenRepository is parsed correctly
+assert "kscript ${PROJECT_DIR}/test/resources/custom_mvn_repo_annot.kts" "kscript with annotations rocks!"
+assert_stderr "kscript ${PROJECT_DIR}/test/resources/illegal_depends_on_arg.kts" '[kscript] [ERROR] Artifact locators must be provided as separate annotation arguments and not as comma-separated list: [com.squareup.moshi:moshi:1.5.0,com.squareup.moshi:moshi-adapters:1.5.0]'
+
+# make sure that @file:MavenRepository is parsed correctly
+assert "kscript ${PROJECT_DIR}/test/resources/script_with_compile_flags.kts" "hoo_ray"
+
+## Ensure dependencies are solved correctly #345
+rm -rf ~/.m2/repository/com/beust
+assert "kscript ${PROJECT_DIR}/test/resources/depends_on_klaxon.kts" "Successfully resolved klaxon"
diff --git a/test/suite/assemble.sh b/test/suite/assemble.sh
new file mode 100644
index 00000000..3b71e813
--- /dev/null
+++ b/test/suite/assemble.sh
@@ -0,0 +1,14 @@
+cd $PROJECT_DIR
+./gradlew clean assemble
+EXIT_CODE="$?"
+cd -
+
+assert "echo $EXIT_CODE" "0"
+
+if [[ "$EXIT_CODE" -ne "0" ]]; then
+  assert_end "assemble"
+
+  echo
+  echo "KScript build terminated with invalid exit code $EXIT_CODE..."
+  exit 1
+fi
diff --git a/test/suite/bootstrap_headers.sh b/test/suite/bootstrap_headers.sh
new file mode 100644
index 00000000..9b7cfcbe
--- /dev/null
+++ b/test/suite/bootstrap_headers.sh
@@ -0,0 +1,19 @@
+f=/tmp/echo_stdin_args.kts
+cp "${PROJECT_DIR}/test/resources/echo_stdin_args.kts" $f
+
+# ensure script works as is
+assert 'echo stdin | '$f' --foo bar' "stdin | script --foo bar"
+
+# add bootstrap header
+assert 'kscript --add-bootstrap-header '$f ''
+
+# ensure adding it again raises an error
+assert_raises 'kscript --add-bootstrap-header '$f 1
+
+# ensure scripts works with header, including stdin
+assert 'echo stdin | '$f' --foo bar' "stdin | script --foo bar"
+
+# ensure scripts works with header invoked with explicit `kscript`
+assert 'echo stdin | kscript '$f' --foo bar' "stdin | script --foo bar"
+
+rm $f
diff --git a/test/suite/cli_helper.sh b/test/suite/cli_helper.sh
new file mode 100644
index 00000000..0ae9b71d
--- /dev/null
+++ b/test/suite/cli_helper.sh
@@ -0,0 +1,8 @@
+## interactive mode without dependencies
+#assert "kscript -i 'exitProcess(0)'" "To create a shell with script dependencies run:\nkotlinc  -classpath ''"
+#assert "echo '' | kscript -i -" "To create a shell with script dependencies run:\nkotlinc  -classpath ''"
+
+
+## first version is disabled because support-auto-prefixing kicks in
+#assert "kscript -i '//DEPS log4j:log4j:1.2.14'" "To create a shell with script dependencies run:\nkotlinc  -classpath '${HOME}/.m2/repository/log4j/log4j/1.2.14/log4j-1.2.14.jar'"
+#assert "kscript -i <(echo '//DEPS log4j:log4j:1.2.14')" "To create a shell with script dependencies run:\nkotlinc  -classpath '${HOME}/.m2/repository/log4j/log4j/1.2.14/log4j-1.2.14.jar'"
diff --git a/test/suite/custom_interpreters.sh b/test/suite/custom_interpreters.sh
new file mode 100644
index 00000000..84b27486
--- /dev/null
+++ b/test/suite/custom_interpreters.sh
@@ -0,0 +1,4 @@
+export PATH=${PATH}:${PROJECT_DIR}/test/resources/custom_dsl
+
+assert "mydsl \"println(foo)\"" "bar"
+assert "${PROJECT_DIR}/test/resources/custom_dsl/mydsl_test_with_deps.kts" "foobar"
diff --git a/test/suite/environment.sh b/test/suite/environment.sh
new file mode 100644
index 00000000..428d13c0
--- /dev/null
+++ b/test/suite/environment.sh
@@ -0,0 +1,11 @@
+## do not run interactive mode prep without script argument
+assert_raises "kscript -i" 1
+
+## make sure that KOTLIN_HOME can be guessed from kotlinc correctly
+assert "unset KOTLIN_HOME; echo 'println(99)' | kscript -" "99"
+
+## todo test what happens if kotlin/kotlinc/java/maven is not in PATH
+
+## run script that tries to find out its own filename via environment variable
+f="${PROJECT_DIR}/test/resources/uses_self_file_name.kts"
+assert "$f" "Usage: $f [-ae] [--foo] file+"
diff --git a/test/suite/idea.sh b/test/suite/idea.sh
new file mode 100644
index 00000000..c819af8d
--- /dev/null
+++ b/test/suite/idea.sh
@@ -0,0 +1,10 @@
+kscript_nocall() { kotlin -classpath ${PROJECT_DIR}/build/libs/kscript.jar kscript.app.KscriptKt "$@";}
+export -f kscript_nocall
+
+## temp projects with include symlinks
+assert_raises "tmpDir=$(kscript_nocall --idea ${PROJECT_DIR}/test/resources/includes/include_variations.kts | cut -f2 -d ' ' | xargs echo); cd $tmpDir && gradle build" 0
+
+## support diamond-shaped include schemes (see #133)
+assert_raises "tmpDir=$(kscript_nocall --idea ${PROJECT_DIR}/test/resources/includes/diamond.kts | cut -f2 -d ' ' | xargs echo); cd $tmpDir && gradle build" 0
+
+## todo re-enable interactive mode tests using kscript_nocall
diff --git a/test/suite/junit.sh b/test/suite/junit.sh
new file mode 100644
index 00000000..4a29e49d
--- /dev/null
+++ b/test/suite/junit.sh
@@ -0,0 +1,6 @@
+cd $PROJECT_DIR
+./gradlew test
+EXIT_CODE="$?"
+cd -
+
+assert "echo $EXIT_CODE" "0"
diff --git a/test/suite/kt_support.sh b/test/suite/kt_support.sh
new file mode 100644
index 00000000..485af03a
--- /dev/null
+++ b/test/suite/kt_support.sh
@@ -0,0 +1,18 @@
+## run kt via interpreter mode
+assert "${PROJECT_DIR}/test/resources/kt_tests/simple_app.kt" "main was called"
+
+## run kt via interpreter mode with dependencies
+assert "kscript ${PROJECT_DIR}/test/resources/kt_tests/main_with_deps.kt" "made it!"
+
+## test misc entry point with or without package configurations
+
+assert "kscript ${PROJECT_DIR}/test/resources/kt_tests/custom_entry_nopckg.kt" "foo companion was called"
+
+assert "kscript ${PROJECT_DIR}/test/resources/kt_tests/custom_entry_withpckg.kt" "foo companion was called"
+
+assert "kscript ${PROJECT_DIR}/test/resources/kt_tests/default_entry_nopckg.kt" "main was called"
+
+assert "kscript ${PROJECT_DIR}/test/resources/kt_tests/default_entry_withpckg.kt" "main was called"
+
+## also make sure that kts in package can be run via kscript
+assert "${PROJECT_DIR}/test/resources/script_in_pckg.kts" "I live in a package!"
diff --git a/test/suite/misc.sh b/test/suite/misc.sh
new file mode 100644
index 00000000..9826c850
--- /dev/null
+++ b/test/suite/misc.sh
@@ -0,0 +1,24 @@
+## prevent regressions of #98 (it fails to process empty or space-containing arguments)
+assert 'kscript "println(args.size)" foo bar' 2         ## regaular args
+assert 'kscript "println(args.size)" "" foo bar' 3      ## accept empty args
+assert 'kscript "println(args.size)" "--params foo"' 1  ## make sure dash args are not confused with options
+assert 'kscript "println(args.size)" "foo bar"' 1       ## allow for spaces
+assert 'kscript "println(args[0])" "foo bar"' "foo bar" ## make sure quotes are not propagated into args
+
+## prevent regression of #181
+assert "echo \"println(123)\" > $KSCRIPT_TEST_DIR/123foo.kts; kscript $KSCRIPT_TEST_DIR/123foo.kts" "123"
+
+## prevent regression of #185
+assert "source ${PROJECT_DIR}/test/resources/home_dir_include.sh" "42"
+
+## prevent regression of #173
+assert "source ${PROJECT_DIR}/test/resources/compiler_opts_with_includes.sh" "hello42"
+
+## Ensure relative includes with in shebang mode
+assert_raises "${PROJECT_DIR}/test/resources/includes/shebang_mode_includes" 0
+
+## Ensure that compilation errors are not cached #349
+# first run (not yet cached)
+kscript ${PROJECT_DIR}/test/resources/invalid_script.kts &> /dev/null
+# real test
+assert "kscript ${PROJECT_DIR}/test/resources/invalid_script.kts 2>&1 | grep \"Compilation of scriplet failed\"" "[kscript] [ERROR] Compilation of scriplet failed:"
diff --git a/test/suite/packaging.sh b/test/suite/packaging.sh
new file mode 100644
index 00000000..7fa3ee0c
--- /dev/null
+++ b/test/suite/packaging.sh
@@ -0,0 +1,13 @@
+## can we resolve relative imports when using tmp-scripts  (see #95)
+assert "rm -f ${PROJECT_DIR}/test/package_example && kscript --package ${PROJECT_DIR}/test/resources/package_example.kts &>/dev/null && ${PROJECT_DIR}/test/package_example 1" "package_me_args_1_mem_5368709120"
+
+## https://unix.stackexchange.com/questions/17064/how-to-print-only-last-column
+assert 'rm -f kscriptlet* && cmd=$(kscript --package "println(args.size)" 2>&1 | tail -n1 | cut -f 5 -d " ") && $cmd three arg uments' "3"
+
+#assert "kscript --package test/resources/package_example.kts" "foo"
+#assert "./package_example 1" "package_me_args_1_mem_4772593664"da
+#assert "echo 1" "package_me_args_1_mem_4772593664"
+#assert_statement 'rm -f kscriptlet* && kscript --package "println(args.size)"' "foo" "bar" 0
+
+# ensure that the jar file is executable
+assert_raises "java -jar build/lib/kscript.jar" 0
diff --git a/test/suite/script_input_modes.sh b/test/suite/script_input_modes.sh
new file mode 100644
index 00000000..1fcbe8d3
--- /dev/null
+++ b/test/suite/script_input_modes.sh
@@ -0,0 +1,49 @@
+## make sure that scripts can be piped into kscript
+assert "source ${PROJECT_DIR}/test/resources/direct_script_arg.sh" "kotlin rocks"
+
+## also allow for empty programs
+assert "kscript ''" ""
+
+## provide script as direct argument
+assert 'kscript "println(1+1)"' '2'
+
+##  use dashed arguments (to prevent regression from https://github.com/holgerbrandl/kscript/issues/59)
+assert 'kscript "println(args.joinToString(\"\"))" --arg u ments' '--arguments'
+assert 'kscript -s "println(args.joinToString(\"\"))" --arg u ments' '--arguments'
+
+## provide script via stidin
+assert "echo 'println(1+1)' | kscript -" "2"
+
+## provide script via stidin with further switch (to avoid regressions of #94)
+assert "echo 'println(1+3)' | kscript - --foo"  "4"
+
+## make sure that heredoc is accepted as argument
+assert "source ${PROJECT_DIR}/test/resources/here_doc_test.sh" "hello kotlin"
+
+## make sure that command substitution works as expected
+assert "source ${PROJECT_DIR}/test/resources/cmd_subst_test.sh" "command substitution works as well"
+
+## make sure that it runs with local script files
+assert "source ${PROJECT_DIR}/test/resources/local_script_file.sh" "kscript rocks!"
+#assert "echo foo" "bar" # known to fail
+
+## make sure that it runs with local script files
+assert "kscript ${PROJECT_DIR}/test/resources/multi_line_deps.kts" "kscript is  cool!"
+
+## scripts with dashes in the file name should work as well
+assert "kscript ${PROJECT_DIR}/test/resources/dash-test.kts" "dash alarm!"
+
+## scripts with additional dots in the file name should work as well.
+## We also test innner uppercase letters in file name here by using .*T*est
+assert "kscript ${PROJECT_DIR}/test/resources/dot.Test.kts" "dot alarm!"
+
+## missing script
+assert_raises "kscript i_do_not_exist.kts" 1
+assert "kscript i_do_not_exist.kts 2>&1" "[kscript] [ERROR] Could not read script from 'i_do_not_exist.kts'"
+
+## make sure that it runs with remote URLs
+assert "kscript https://raw.githubusercontent.com/holgerbrandl/kscript/master/test/resources/url_test.kts" "I came from the internet"
+assert "kscript https://git.io/fxHBv" "main was called"
+
+# repeated compilation of buggy same script should end up in error again
+assert_raises "kscript '1-'; kscript '1-'" 1
diff --git a/test/suite/support_api.sh b/test/suite/support_api.sh
new file mode 100644
index 00000000..259e947e
--- /dev/null
+++ b/test/suite/support_api.sh
@@ -0,0 +1,6 @@
+## make sure that one-liners include support-api
+assert 'echo "foo${NL}bar" | kscript -t "stdin.print()"' $'foo\nbar'
+assert 'echo "foo${NL}bar" | kscript -t "lines.print()"' $'foo\nbar'
+#echo "$'foo\nbar' | kscript 'lines.print()'
+
+assert_statement 'echo "foo${NL}bar" | kscript -s --text "lines.split().select(1, 2, -3)"' "" "[ERROR] Can not mix positive and negative selections" 1
diff --git a/test/test_suite.sh b/test/test_suite.sh
index 09581a36..20a670a4 100755
--- a/test/test_suite.sh
+++ b/test/test_suite.sh
@@ -3,7 +3,6 @@
 # Provide suite names which you want to execute as a parameter
 # Example:
 # no parameters or 'ALL' - execute all test suites
-# '-' (dash) - just compile - no suites executed
 # 'junit' - execute just unit tests
 
 SCRIPT_DIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
@@ -16,297 +15,23 @@ echo
 kscript --clear-cache
 echo
 
-########################################################################################################################
-echo "Compiling KScript... Please wait..."
-
-cd $PROJECT_DIR
-./gradlew clean assemble
-EXIT_CODE="$?"
-cd -
-
-if [[ "$EXIT_CODE" -ne "0" ]]; then
-  echo
-  echo "KScript build terminated with invalid exit code $EXIT_CODE..."
-  exit 1
-fi
-
 ########################################################################################################################
 
 source "$SCRIPT_DIR/setup_environment.sh"
 echo
 
 ########################################################################################################################
-SUITE="junit"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  cd $PROJECT_DIR
-  ./gradlew test
-  EXIT_CODE="$?"
-  cd -
-
-  assert "echo $EXIT_CODE" "0"
-
-  assert_end "$SUITE"
-fi
-
-########################################################################################################################
-SUITE="script_input_modes"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  ## make sure that scripts can be piped into kscript
-  assert "source ${PROJECT_DIR}/test/resources/direct_script_arg.sh" "kotlin rocks"
-
-  ## also allow for empty programs
-  assert "kscript ''" ""
-
-  ## provide script as direct argument
-  assert 'kscript "println(1+1)"' '2'
-
-  ##  use dashed arguments (to prevent regression from https://github.com/holgerbrandl/kscript/issues/59)
-  assert 'kscript "println(args.joinToString(\"\"))" --arg u ments' '--arguments'
-  assert 'kscript -s "println(args.joinToString(\"\"))" --arg u ments' '--arguments'
-
-  ## provide script via stidin
-  assert "echo 'println(1+1)' | kscript -" "2"
-
-  ## provide script via stidin with further switch (to avoid regressions of #94)
-  assert "echo 'println(1+3)' | kscript - --foo"  "4"
-
-  ## make sure that heredoc is accepted as argument
-  assert "source ${PROJECT_DIR}/test/resources/here_doc_test.sh" "hello kotlin"
-
-  ## make sure that command substitution works as expected
-  assert "source ${PROJECT_DIR}/test/resources/cmd_subst_test.sh" "command substitution works as well"
-
-  ## make sure that it runs with local script files
-  assert "source ${PROJECT_DIR}/test/resources/local_script_file.sh" "kscript rocks!"
-  #assert "echo foo" "bar" # known to fail
-
-  ## make sure that it runs with local script files
-  assert "kscript ${PROJECT_DIR}/test/resources/multi_line_deps.kts" "kscript is  cool!"
-
-  ## scripts with dashes in the file name should work as well
-  assert "kscript ${PROJECT_DIR}/test/resources/dash-test.kts" "dash alarm!"
-
-  ## scripts with additional dots in the file name should work as well.
-  ## We also test innner uppercase letters in file name here by using .*T*est
-  assert "kscript ${PROJECT_DIR}/test/resources/dot.Test.kts" "dot alarm!"
-
-  ## missing script
-  assert_raises "kscript i_do_not_exist.kts" 1
-  assert "kscript i_do_not_exist.kts 2>&1" "[kscript] [ERROR] Could not read script from 'i_do_not_exist.kts'"
-
-  ## make sure that it runs with remote URLs
-  assert "kscript https://raw.githubusercontent.com/holgerbrandl/kscript/master/test/resources/url_test.kts" "I came from the internet"
-  assert "kscript https://git.io/fxHBv" "main was called"
-
-  # repeated compilation of buggy same script should end up in error again
-  assert_raises "kscript '1-'; kscript '1-'" 1
-
-  assert_end "$SUITE"
-fi
-
-########################################################################################################################
-#SUITE="cli_helper"
-#echo
-#echo "Starting $SUITE tests:"
-
-## interactive mode without dependencies
-#assert "kscript -i 'exitProcess(0)'" "To create a shell with script dependencies run:\nkotlinc  -classpath ''"
-#assert "echo '' | kscript -i -" "To create a shell with script dependencies run:\nkotlinc  -classpath ''"
-
-
-## first version is disabled because support-auto-prefixing kicks in
-#assert "kscript -i '//DEPS log4j:log4j:1.2.14'" "To create a shell with script dependencies run:\nkotlinc  -classpath '${HOME}/.m2/repository/log4j/log4j/1.2.14/log4j-1.2.14.jar'"
-#assert "kscript -i <(echo '//DEPS log4j:log4j:1.2.14')" "To create a shell with script dependencies run:\nkotlinc  -classpath '${HOME}/.m2/repository/log4j/log4j/1.2.14/log4j-1.2.14.jar'"
-
-#assert_end "$SUITE"
-
-########################################################################################################################
-SUITE="environment"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  ## do not run interactive mode prep without script argument
-  assert_raises "kscript -i" 1
-
-  ## make sure that KOTLIN_HOME can be guessed from kotlinc correctly
-  assert "unset KOTLIN_HOME; echo 'println(99)' | kscript -" "99"
-
-  ## todo test what happens if kotlin/kotlinc/java/maven is not in PATH
-
-  ## run script that tries to find out its own filename via environment variable
-  f="${PROJECT_DIR}/test/resources/uses_self_file_name.kts"
-  assert "$f" "Usage: $f [-ae] [--foo] file+"
-
-  assert_end "$SUITE"
-fi
-
-########################################################################################################################
-SUITE="annotation_driven_configuration"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  ## there are some dependencies which are not jar, but maybe pom, aar,... make sure they work, too
-  assert "kscript ${PROJECT_DIR}/test/resources/depends_on_with_type.kts" "getBigDecimal(1L): 1"
-
-  # make sure that @file:DependsOn is parsed correctly
-  assert "kscript ${PROJECT_DIR}/test/resources/depends_on_annot.kts" "kscript with annotations rocks!"
-
-  # make sure that @file:DependsOnMaven is parsed correctly
-  assert "kscript ${PROJECT_DIR}/test/resources/depends_on_maven_annot.kts" "kscript with annotations rocks!"
-
-  # make sure that dynamic versions are matched properly
-  assert "kscript ${PROJECT_DIR}/test/resources/depends_on_dynamic.kts" "dynamic kscript rocks!"
-
-  # make sure that @file:MavenRepository is parsed correctly
-  assert "kscript ${PROJECT_DIR}/test/resources/custom_mvn_repo_annot.kts" "kscript with annotations rocks!"
-  assert_stderr "kscript ${PROJECT_DIR}/test/resources/illegal_depends_on_arg.kts" '[kscript] [ERROR] Artifact locators must be provided as separate annotation arguments and not as comma-separated list: [com.squareup.moshi:moshi:1.5.0,com.squareup.moshi:moshi-adapters:1.5.0]'
-
-  # make sure that @file:MavenRepository is parsed correctly
-  assert "kscript ${PROJECT_DIR}/test/resources/script_with_compile_flags.kts" "hoo_ray"
-
-  ## Ensure dependencies are solved correctly #345
-    rm -rf ~/.m2/repository/com/beust
-    assert "kscript ${PROJECT_DIR}/test/resources/depends_on_klaxon.kts" "Successfully resolved klaxon"
-
-  assert_end "$SUITE"
-fi
-
-########################################################################################################################
-SUITE="support_api"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  ## make sure that one-liners include support-api
-  assert 'echo "foo${NL}bar" | kscript -t "stdin.print()"' $'foo\nbar'
-  assert 'echo "foo${NL}bar" | kscript -t "lines.print()"' $'foo\nbar'
-  #echo "$'foo\nbar' | kscript 'lines.print()'
-
-  assert_statement 'echo "foo${NL}bar" | kscript -s --text "lines.split().select(1, 2, -3)"' "" "[ERROR] Can not mix positive and negative selections" 1
-
-  assert_end "$SUITE"
-fi
-
-########################################################################################################################
-SUITE="kt_support"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  ## run kt via interpreter mode
-  assert "${PROJECT_DIR}/test/resources/kt_tests/simple_app.kt" "main was called"
-
-  ## run kt via interpreter mode with dependencies
-  assert "kscript ${PROJECT_DIR}/test/resources/kt_tests/main_with_deps.kt" "made it!"
-
-  ## test misc entry point with or without package configurations
-
-  assert "kscript ${PROJECT_DIR}/test/resources/kt_tests/custom_entry_nopckg.kt" "foo companion was called"
-
-  assert "kscript ${PROJECT_DIR}/test/resources/kt_tests/custom_entry_withpckg.kt" "foo companion was called"
-
-  assert "kscript ${PROJECT_DIR}/test/resources/kt_tests/default_entry_nopckg.kt" "main was called"
-
-  assert "kscript ${PROJECT_DIR}/test/resources/kt_tests/default_entry_withpckg.kt" "main was called"
-
-  ## also make sure that kts in package can be run via kscript
-  assert "${PROJECT_DIR}/test/resources/script_in_pckg.kts" "I live in a package!"
-
-  assert_end "$SUITE"
-fi
-
-########################################################################################################################
-SUITE="custom_interpreters"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  export PATH=${PATH}:${PROJECT_DIR}/test/resources/custom_dsl
-
-  assert "mydsl \"println(foo)\"" "bar"
-
-  assert "${PROJECT_DIR}/test/resources/custom_dsl/mydsl_test_with_deps.kts" "foobar"
-
-  assert_end "$SUITE"
-fi
-
-########################################################################################################################
-SUITE="misc"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  ## prevent regressions of #98 (it fails to process empty or space-containing arguments)
-  assert 'kscript "println(args.size)" foo bar' 2         ## regaular args
-  assert 'kscript "println(args.size)" "" foo bar' 3      ## accept empty args
-  assert 'kscript "println(args.size)" "--params foo"' 1  ## make sure dash args are not confused with options
-  assert 'kscript "println(args.size)" "foo bar"' 1       ## allow for spaces
-  assert 'kscript "println(args[0])" "foo bar"' "foo bar" ## make sure quotes are not propagated into args
-
-  ## prevent regression of #181
-  assert "echo \"println(123)\" > $KSCRIPT_TEST_DIR/123foo.kts; kscript $KSCRIPT_TEST_DIR/123foo.kts" "123"
-
-  ## prevent regression of #185
-  assert "source ${PROJECT_DIR}/test/resources/home_dir_include.sh" "42"
-
-  ## prevent regression of #173
-  assert "source ${PROJECT_DIR}/test/resources/compiler_opts_with_includes.sh" "hello42"
-
-  ## Ensure relative includes with in shebang mode
-  assert_raises "${PROJECT_DIR}/test/resources/includes/shebang_mode_includes" 0
-
-  ## Ensure that compilation errors are not cached #349
-  # first run (not yet cached)
-  kscript ${PROJECT_DIR}/test/resources/invalid_script.kts &> /dev/null
-  # real test
-  assert "kscript ${PROJECT_DIR}/test/resources/invalid_script.kts 2>&1 | grep \"Compilation of scriplet failed\"" "[kscript] [ERROR] Compilation of scriplet failed:"
-
-  assert_end "$SUITE"
-fi
-
-########################################################################################################################
-SUITE="bootstrap_headers"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  f=/tmp/echo_stdin_args.kts
-  cp "${PROJECT_DIR}/test/resources/echo_stdin_args.kts" $f
-
-  # ensure script works as is
-  assert 'echo stdin | '$f' --foo bar' "stdin | script --foo bar"
-
-  # add bootstrap header
-  assert 'kscript --add-bootstrap-header '$f ''
-
-  # ensure adding it again raises an error
-  assert_raises 'kscript --add-bootstrap-header '$f 1
-
-  # ensure scripts works with header, including stdin
-  assert 'echo stdin | '$f' --foo bar' "stdin | script --foo bar"
-
-  # ensure scripts works with header invoked with explicit `kscript`
-  assert 'echo stdin | kscript '$f' --foo bar' "stdin | script --foo bar"
-
-  rm $f
-
-  assert_end "$SUITE"
-fi
-
-########################################################################################################################
-SUITE="packaging"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  ## can we resolve relative imports when using tmp-scripts  (see #95)
-  assert "rm -f ${PROJECT_DIR}/test/package_example && kscript --package ${PROJECT_DIR}/test/resources/package_example.kts &>/dev/null && ${PROJECT_DIR}/test/package_example 1" "package_me_args_1_mem_5368709120"
-
-  ## https://unix.stackexchange.com/questions/17064/how-to-print-only-last-column
-  assert 'rm -f kscriptlet* && cmd=$(kscript --package "println(args.size)" 2>&1 | tail -n1 | cut -f 5 -d " ") && $cmd three arg uments' "3"
-
-  #assert "kscript --package test/resources/package_example.kts" "foo"
-  #assert "./package_example 1" "package_me_args_1_mem_4772593664"da
-  #assert "echo 1" "package_me_args_1_mem_4772593664"
-  #assert_statement 'rm -f kscriptlet* && kscript --package "println(args.size)"' "foo" "bar" 0
-
-  # ensure that the jar file is executable
-  assert_raises "java -jar build/lib/kscript.jar" 0
-
-  assert_end "$SUITE"
-fi
-
-########################################################################################################################
-SUITE="idea"
-if start_suite $SUITE $REQUESTED_SUITES; then
-  kscript_nocall() { kotlin -classpath ${PROJECT_DIR}/build/libs/kscript.jar kscript.app.KscriptKt "$@";}
-  export -f kscript_nocall
-
-  ## temp projects with include symlinks
-  assert_raises "tmpDir=$(kscript_nocall --idea ${PROJECT_DIR}/test/resources/includes/include_variations.kts | cut -f2 -d ' ' | xargs echo); cd $tmpDir && gradle build" 0
-
-  ## support diamond-shaped include schemes (see #133)
-  assert_raises "tmpDir=$(kscript_nocall --idea ${PROJECT_DIR}/test/resources/includes/diamond.kts | cut -f2 -d ' ' | xargs echo); cd $tmpDir && gradle build" 0
-
-  ## todo re-enable interactive mode tests using kscript_nocall
 
-  assert_end "$SUITE"
-fi
+start_suite "assemble" $REQUESTED_SUITES
+start_suite "junit" $REQUESTED_SUITES
+start_suite "script_input_modes" $REQUESTED_SUITES
+#start_suite "cli_helper" $REQUESTED_SUITES
+start_suite "environment" $REQUESTED_SUITES
+start_suite "annotation_driven_configuration" $REQUESTED_SUITES
+start_suite "support_api" $REQUESTED_SUITES
+start_suite "kt_support" $REQUESTED_SUITES
+start_suite "custom_interpreters" $REQUESTED_SUITES
+start_suite "misc" $REQUESTED_SUITES
+start_suite "bootstrap_headers" $REQUESTED_SUITES
+#start_suite "packaging" $REQUESTED_SUITES
+#start_suite "idea" $REQUESTED_SUITES