nuts is a Java™ Package Manager that helps discovering, downloading, assembling and executing
local and remote artifacts (packages) in a very handy way. Unlike maven which resolves dependencies at compile time,
nuts solves dependencies at install time and, as a result, saves disk and bandwidth by downloading and caching
only libraries required for the current environment. Nuts is unique in that it reuses maven and other build tool
descriptor formats to solve dependency graph, and does not, whatsoever, have any requirement on existing
maven created packages.

Nuts stands for Network Updatable Things Services tool. It is designed to support multiple package formats and even
multiple languages (platforms like dotnet and python), even-though, the current implementation supports only java.
nuts artifacts are  stored  into repositories. A  repository  may be local for  storing local nuts
or remote for accessing  remote artifacts (good examples  are  remote maven  repositories). It may
also be a proxy repository so that remote artifacts are fetched and cached locally to save network
resources.

One manages a set of repositories called a  workspace (analogous to pip 'virtualenv'). Managed packages
(artifacts) have descriptors that depict dependencies between them. This dependency is seamlessly handled by  nuts
to resolve and download and cache on-need dependencies over the wire.

nuts is a swiss army knife tool as it acts like (and supports) maven build tool to have an abstract
view of the the  artifacts dependency and like  zypper/apt-get/pip/npm  package manager tools
to install and uninstall artifacts allowing multiple versions of the very same artifact to  be installed.

Although nuts focuses on Java™ artifacts, it still supports, by design, native and all non Java™ artifacts.
Dependencies are fetched according to the current operating system type, distribution and hardware
architectures.

nuts works either as standalone application or as Java™ library to enable dynamic and dependency
aware class loading and brings a rich toolset to provide a versatile portable command line tools such
as nsh (a bash like shell), tomcat, derby ... wrapper tools to make it easier providing
development , test and deployment reproducible environments.

With container concepts in mind, nuts is the perfect Java™ application tool for Docker, CoreOs
and other container engines.

##)  
COMMON VERBS:


install,uninstall,update : install/uninstall/update an artifact (using its fetched/deployed installer)
fetch,push               : download, upload to remote repositories
search                   : search for existing/installable artifacts
exec                     : execute an artifact (tool)
deploy, undeploy         : manage artifacts on the local repositories

##)  
SYNOPSIS:


nuts [<-options>]...   ...

##)  
VERSIONS:


Boot API     Version: ${nuts.workspace-boot.version}
Boot Runtime Version: ${nuts.workspace-runtime.version}
Java™        Version: ${java.version} (${java.vm.name})

##)  
NUTS OPTIONS:


 There are four (4) types of options : 
 * create options
 * create exported options
 * open options
 * open exported options

 create options are considered solely when creating a new workspace. They will be persisted then (to the configuration file)
                    but they will be ignored elsewhere if the workspace already exists : configured parameters will be in use.

 create exported options are considered both when creating a new workspace and when running it. If they are specified in creation
                    they will be persisted. If they are specified later they will override persisted values without persisting the changes

 open options are transient (non persistent) options that will override any configured value (if any) and will be
                     in use in the current process (and ignored elsewhere). Such options will be considered in creating workspaces
                     as well but still they are not persistent.

 open exported options are open (so transient, non persistent) options that will override any configured value (if any)
                      having the ability to be exported to any Java™ child process (as system property -D...)


###)  
NUTS CREATE EXPORTED OPTIONS:


 --workspace   (default is "" ad is equivalent to "default-workspace")
 -w  
      workspace location to open (or create).
      this defaults to default-workspace. Typically this refers to ~/.config/nuts/default-workspace on *NIX Platforms*
      (when --system-conf-home is not specified). workspace location contains mainly config information.

 --user        (default is "")
 -u           
      workspace username.
      if not specified, all access to nuts will be with anonymous identity. so to promote user privileges, one may
      specify user credentials (see --password )

 --password    (default is "")
 -p   
      workspace password.
      They must be provided when --user is present.

 -V   (default is "" and points to the currently loaded api version)
 --boot-version  
 --boot-api-version  
      run a new/different instance of nuts with the specified version
 --sandbox=true|false  (default is false )
      when creating the workspace, generate a random workspace, for testing purposes.
      sandbox mode will be propagated/exported as --confined
 --confined=true|false  (default is false )
      use a confined workspace that does not allow user wide or system wide alteration
 --isolation=system|user|confined|sandbox  (default is system )
      use the level of isolation for the workspace

 --boot-runtime   (default is "" and points to the latest compatible nuts-runtime artifact)
      load runtime (nuts-runtime) version. either version may be expressed or full nuts implementation
      (other than nuts-runtime) should be defined

 --java        (default is "" and points to the currently loaded JVM executable)
 --boot-java  
 -j  
      Java™ command to run new instance of nuts

 --java-home          (default is "" and points to the currently loaded JVM)
 --boot-java-home  
 -J     (default is "")
      Java™ home to run new instance of nuts. When Java™ command is present, this will be ignored.

 --java-options         (default is "")
 --boot-java-options   
 -J  
      Java™ options to run new instance of nuts

###)  
NUTS CREATE OPTIONS:



 --archetype  (default is "default")
 -A 
      workspace archetype to create (if workspace not found).
      when opening a non existing workspace, nuts will create it
      using the default archetype. Supported archetypes are :
          default : should handle most cases. Will create 6 repositories
                    local            : containing local nuts (java and non java nuts).
                    maven-local      : referencing ~/.m2/repository local maven repository.
                    maven-central    : referencing https://repo.maven.apache.org/maven2/ (with cache support).
                    system           : referencing global (root, system wide) repository if available.
                    This list can be altered using --repos options, using =, + and - modifiers.
                    When you use --repos=+spring, or simply --repos=spring the spring repos will be appended to this list
                    When you use --repos=-maven-central,system, you will disable both maven-central and system
                    When you use --repos==maven-central, this list is totally replaced by 'maven-central'
          minimal : will create an almost empty workspace with a single nuts local repository and no users.
                        You should use it in conjunction with --boot-repos options to enable a valid location from.
                        This list is not altered using "--repos" options, using '=', '+' and '-' modifiers.
                        which nuts would be downloaded as well.
          server  : will create an almost empty workspace with a single nuts local repository
                        and a couple of users guest (read support) and contributor (write support).
                        You should use it in conjunction with --boot-repos options to enable a valid location from
                                                which nuts would be downloaded as well.

 --store-strategy  (default is "exploded" for names and "standalone" for paths)
      Define store strategy used for persisting configuration and data of the workspace.
      Valid values of  are exploded, standalone.
      exploded   : use distinct folders for temp, var, lib, config ... folders (this is the default)
      standalone : use a self contained folder for all types of data of the workspace. This is interesting for sharing
                   workspaces across multiple machines.
      If the workspace location (in  --workspace option) is a simple name (without '/'), the store strategy
      defaults to exploded. In all other cases, it defaults to standalone

 -S
 --standalone (default is true for path based workspaces)
       will boot with standalone strategy so that all files will be stored in the workspace folder
       overriding workspace config. same as  --store-strategy standalone
 
 --exploded-workspace  (default is true for name based workspaces)
       will boot with exploded strategy so that all file will be stored distinct folders (cache, and log)
       particularly will be stored elsewhere depending on on configuration.
       same as  --store-strategy exploded

 --repo-store-strategy  (default is exploded for name based workspaces)
      Defines store strategy used for persisting config and data of the repositories.
      Valid values of  are exploded, standalone.
      exploded   : use distinct folders for temp, var, lib, config ... folders (this is the default)
      standalone : use a self contained folder for all types of data of the repository (under repository's main folder).
                   This is interesting for sharing workspaces across multiple machines.

 --standalone-repositories (default false)
       for newly created repos, will boot with standalone strategy so that all file will be stored in the repository's folder
       overriding workspace config. same as  --repo-store-strategy standalone
 
 --exploded-repositories (default true)
       for newly created repos, boot with exploded strategy so that all file will be stored distinct folders (cache, and log)
       particularly will be stored elsewhere depending on on configuration.
       same as  --repo-store-strategy exploded (this is default)

 --standalone (default false if the workspace location is a simple name, and true if not)
    Equivalent of --standalone-workspace

 --exploded  (default true if the workspace location is a simple name, and false if not)
    Equivalent of --exploded-workspace

 --store-layout   (default use system layout)
      Defines store layout relatively to the running operating system. This resolves root locations of data folders.
      That is to say that all 'config' folders for instance will be located at the location defined by the layout.

      Valid values of  are system, windows, linux, macos and unix
      system     : resolve the running operating system (windows, linux, ...) and select appropriate folder
      windows    : always use windows layout (even if running on iOS)
      linux      : always use linux layout (even if running on windows)
      unix       : always use linux/unix layout (even if running on windows)
      macos      : always use macos layout (even if running on windows)

      Data folders of nuts are :
        apps     : executable binaries folder. Equivalent to linux's '/bin' folder. It is defined as
                        "base directory relative to which reusable executable applications and scripts should be written"
        lib      : non executable binaries (libraries) folder. Equivalent to linux's '/usr/lib' folder. It is defined as
                        "base directory relative to which reusable libraries should be written"
        config   : configuration/settings files folder. equivalent to XDG spec's XDG_CONFIG_HOME folder defined as
                        "base directory relative to which user-specific configuration files should be written"
        var      : data files folder. More or less related to XDG spec's XDG_DATA_HOME folder. It is defined as
                        "the base directory relative to which user-specific non executable data files should be stored"
        log      : log/trace files folder. Equivalent to XDG_LOG_HOME a non standard XDG variable defined as
                        "the base directory relative to which application non-essential data for trace and monitoring
                        should be stored"
        temp     : temporary files folder. Equivalent to user/system temp folder defined as
                        "the base directory relative to which application temporary data should be stored"
        cache    : cache folder. Equivalent to XDG spec's XDG_CACHE_HOME folder defined as
                        "the base directory relative to which user-specific non-essential data files should be stored"
        run      : run folder. Equivalent to to XDG spec's XDG_RUNTIME_HOME bin folder defined as
                        "the base directory relative to which user-specific non-essential runtime files and other
                        file objects (such as sockets, named pipes, ...) should be stored"

     In the Windows layout, default (home) locations resolve to ($HOME is the user's home folder)
        apps     : "$HOME/AppData/Roaming/nuts/apps"
        lib      : "$HOME/AppData/Roaming/nuts/lib"
        config   : "$HOME/AppData/Roaming/nuts/config"
        var      : "$HOME/AppData/Roaming/nuts/var"
        log      : "$HOME/AppData/Roaming/nuts/log"
        temp     : "$HOME/AppData/Local/nuts/temp"
        cache    : "$HOME/AppData/Local/nuts/cache"
        run      : "$HOME/AppData/Local/nuts/run"

     In the Linux/Unix/MacOS layout, default locations resolve (according to XDG Base Directory Specification) 
     to ($HOME is the user's home folder)
        config   : "$HOME/.config/nuts"
        apps     : "$HOME/.local/share/nuts/apps"
        lib      : "$HOME/.local/share/nuts/lib"
        var      : "$HOME/.local/share/nuts/var"
        log      : "$HOME/.local/log/nuts"
        cache    : "$HOME/.cache/nuts"
        temp     : "$java.io.tmpdir/$username/nuts"
        run      : "/run/user/$USER_ID/nuts"
     
    These home locations are tuned individually using the following options
            --system-bin-home 
            --system-lib-home 
            --system-conf-home 
            --system-var-home 
            --system-log-home 
            --system-temp-home 
            --system-cache-home 
            --system-run-home 

            ---bin-home 
            ---lib-home 
            ---conf-home 
            ---var-home 
            ---log-home 
            ---temp-home 
            ---cache-home 
            ---run-home 

            where  in one of windows, linux, unix, macos or system.
            This helps moving workspace folder from/to distinct os families while providing a centralized configuration.
            when using system OS family, the effective OS family will be detected at runtime.

 --system-layout or --system(default behaviour)
       will use current system layout to resolve folder candidates for log,config,apps ....
       same as  sh --store-layout system
 
 --windows-layout (default is true on windows systems)
       will use windows layout to resolve folder candidates for log,config,apps ....
       same as  --store-layout  windows

 --linux-layout  (default is true on linux systems)
       will use linux/unix layout to resolve folder candidates for log,config,apps ....
       same as  --store-layout  linux

 More tuning of these folders may be done by defining the folders location directly 
 instead of the folder's home locations using the following options :
            --bin-location 
            --lib-location 
            --config-location 
            --var-location 
            --log-location 
            --temp-location 
            --cache-location 
            --run-location 

 --install-companions or -k   (default is false)
       install companion tools.
 
 --switch  (default is false)
      When creating a new workspace, by default, only default workspace (--workspace="") updates .bashrc file
      (or equivalent, according to the current installed and used shell) to point to that workspace. So that, when you
      type nuts it is that workspace that is used. You can change choose to "switch" the binding to the currently
      created workspace by arming this flag.

 --init-scripts  (default is true for default archetype)
      When creating a new workspace, you can select to enable or disable creation of os shell scripts to point to nuts
      and other installed artifacts using --!init-scripts  flag.

 --init-launchers  (default is true for default archetype)
      When creating a new workspace, you can select to enable or disable creation of menus and desktop icons by using
      --!init-launchers  flag. This option implies --init-scripts 

 --init-java  (default is true for default archetype)
      When creating a new workspace, you can select to enable or disable registration of installed JDK/JRE in the system
      by using --!init-java  flag. This option implies --init-scripts 

 --init-platforms  (default is true for default archetype)
      When creating a new workspace, you can select to enable or disable registration of installed platforms (including
      java) in the system by using --!init-platforms  flag. This option implies --init-java 


 ) NUTS OPEN EXPORTED OPTIONS:
 --global  or -g  (default is false)
      use root/system wide workspace instead of user's own workspace.
      requires admin privileges.
      shared/system workspace is located at :
      Windows    : "$ProgramFiles/nuts/default-workspace" 
      Linux/Unix : "/usr/share/nuts/default-workspace" 
      More generally folder homes are defines as follows :
      Windows Layout   :
        apps     : "$ProgramFiles/nuts" 
        lib      : "$ProgramFiles/nuts" 
        config   : "$ProgramFiles/nuts" 
        var      : "$ProgramFiles/nuts" 
        log      : "$ProgramFiles/nuts" 
        temp     : "$TMP/nuts" 
        cache    : "$ProgramFiles/nuts" 
        run      : "$ProgramFiles/nuts" 
      Linux Layout    :
        apps     : "/opt/nuts/apps" 
        lib      : "/opt/nuts/lib" 
        config   : "/etc/opt/nuts" 
        var      : "/var/opt/nuts" 
        log      : "/var/log/nuts" 
        temp     : "/tmp/nuts/global" 
        cache    : "/var/cache/nuts" 
        run      : "/tmp/run/nuts/global" 

 --color or -c  (default is 'auto')
      
    --color=always|yes|true|y|formatted
      enables formatted (colorful) terminal (formatted terminal)
    --color=inherited|h
      use parent process terminal mode
    --color=auto|system|s
      auto detected terminal (default)
    --color=never|none|no|false|n
      equivalent to --no-color
    warning2 Attention : --color argument, should it accept a value, it must be an immediate one (with '=')
 -C
 --no-color
      disable formatted (colorful) terminal (filtered terminal).

 --trace (default is true)
 -t
      apply trace mode which allows a more verbose output

 --transitive (default is true)
      consider transitive repositories

 --index (default is true)
      search into indexes

 --cached  (default is true)
      use cache whenever possible

 --progress[=<options>]
 -P[=<options>]
      configure progress monitor. valid values include
        true|enable
            progress monitor is enabled (default)
        no|false|n
            progress monitor is disabled
        newline || %n
            progress monitor writes every message in a new line
        log
            progress monitor writes every message to the log as finest (aka verbose)
        log=off|severe|warning|info|config|fine|finer|finest|verbose|all
        log-off|log-severe|log-warning|log-info|log-config|log-fine|log-finer|log-finest|log-verbose|log-all
            progress monitor writes every message to the log with the selected level


 --solver <solverName> (default is default)
      configure dependency solver used to resolve dependencies.
        default     : defaults to maven, uses maven solver regardless of artifact configured solver
        maven       : uses maven solver regardless of artifact configured solver
        gradle      : uses gradle solver regardless of artifact configured solver
        descriptor        : uses artifact descriptor's solver, or default if not specified.
                               and switches solver if a dependency requires another solver
        maven-first : uses maven solver for the first artifact/dependency, then switches is the
                               dependency descriptor requires another solver
        gradle-first: uses gradle solver for the first artifact/dependency, then switches is the
                               dependency descriptor requires another solver

 --plain[=<format-options>]
      define plain text format as default output format (this is default)

 -T[=<format-type>[:<format-options>]]
 --output-format[=<format-options>[:<format-options>]]
      define format as default output format. --output-format=json is equivalent to --json
      beside one  specify some extra options for the format, such as --output-format=json:lenient

 --json[=<format-options>]
      define json format as default output format

 --table[=<format-options>]
      define table format as default output format

 --tree[=<format-options>]
      define tree format as default output format

 --xml[=<format-options>]
      define xml format as default output format

 --props[=<format-options>]
      define props format as default output format

 --output-format-option=<format-options>
 | -T=<format-options>
                  : add specific format option
 --read-only or -R
      read only mode. All changes to the workspace - if ever - are not persisted.

 --verbose , --log-verbose  , --log-finest  , --log-info , --log-fine ,
 --log-finer , --log-severe , --log-warning , --log-config ,
 --log-off , --log-off 
      apply logging level to both terminal and file

 --log-term-verbose  , --log-term-finest  , --log-term-info , --log-term-fine ,
 --log-term-finer , --log-term-severe , --log-term-warning , --log-term-config ,
 --log-term-off , --log-term-off
      apply logging level to terminal

 --log-file-verbose  , --log-file-finest  , --log-file-info , --log-file-fine ,
 --log-file-finer , --log-file-severe , --log-file-warning , --log-file-config ,
 --log-file-off , --log-file-off
      apply logging level to terminal

 --log-file-size       <size>
      define the maximum number of mega to write to any one file. size is either expressed in mega or suffixed with unit.
      supported units are :
        k or kb : for kilo-bytes (example 1024k)
        m or mb : for mega-bytes (example 10m)
        g or gb : for giga-bytes (example 10Gb)
      The size is always a multiple of Mb

 --log-file-base     <log-folder-path>
      define log file folder path

 --log-file-name       <log-file-name-pattern>
      define log file name pattern. this defaults to "nuts-%g.log"

 --log-file-count      <number>
      define the number of files to use (in rotating log)

 --log-inherited
      calls rootLogger.setUseParentHandlers(true) to inherit log handlers.

 --exclude-extension     <extension-id-list>
      exclude extensions from being loaded at runtime. list is separated with characters " ,;"

 --exclude-repository   <repository-list>
      exclude repositories from being loaded at runtime. list is separated with characters " ,;"

 -r <repository-path>
 --repository   <repository-path>
 --repositories <repository-path>
 --repos        <repository-path>
      register one or multiple (comma ',' separated) temporary repositories at the given path
      repositories follow the following pattern
      [+-=]?(=)?([+]@)?
      some examples are:
      --repos=+jcenter 
      --repos=-https://jcenter.bintray.com 
      --repos=jcenter=https://jcenter.bintray.com 
      --repos=jcenter=maven@https://jcenter.bintray.com 
      --repos==dev=maven@htmlfs:https://thevpc.net/maven 

      the prefix operator (+,-,=) when specified defines whether the repository is
        to include (+), to exclude (-) or to replace (=) ie all existing repositories will be
        discarded and replaced with the given list of repositories.
      This list will be used when creating a new workspace. In that conditions, the list may affects the 'archetype' considered.
      For example, the default repositories in "default" archetype are 'local,maven-local,maven-central,system'.
          "--repos=+jcenter" produces a final repository list of 'local,maven-local,maven-central,system,jcenter'
          "--repos=jcenter"  also produces a final repository list of 'local,maven-local,maven-central,system,jcenter'
          "--repos=-system"  produces a final repository list of 'local,maven-local,maven-central'
          "--repos==system"  produces a final repository list of 'system'
      The repository names supported are
                    local          : local user nuts folder repository
                    system         : local user nuts folder repository
                    .m2
                    m2
                    maven-local    : local user maven folder repository (~/.m2)
                    maven
                    central
                    maven-central  : maven central repository at https://repo.maven.apache.org/maven2
                    jcenter        : maven repository at https://jcenter.bintray.com
                    jboss          : maven repository at https://repository.jboss.org/nexus/content/repositories/releases
                    clojars        : maven repository at https://repo.clojars.org
                    atlassian      : maven repository at https://packages.atlassian.com/maven/public
                    atlassian-snapshot :
                                              maven repository at https://packages.atlassian.com/maven/public-snapshot
                    oracle         : maven repository at https://maven.oracle.com
                    google         : maven repository at https://maven.google.com
                    spring
                    spring-framework
                                            : maven repository at https://repo.spring.io/release
                    maven-thevpc-git
                    vpc-public-maven
                                            : maven repository at https://raw.githubusercontent.com/thevpc/vpc-public-maven/master
                    nuts-thevpc-git
                    vpc-public-nuts
                                            : maven repository at https://raw.githubusercontent.com/thevpc/vpc-public-nuts/master
                    dev
                    thevpc         : maven repository at https://thevpc.net/maven
      The repository types supported are:
                    maven          standard maven repository
                    nuts           standard nuts repository
      The supported protocols are:
                    http  https for http(s) server access, most likely such repositories are not navigable. i.e, you
                                            can download an artificat if and only you know its full coordinates
                    htmlfs         for http(s) server access that is navigable by 'scrapping' its html content.
                                            At boot time, only standard 'Tomcat Http Server' standard directory servlet is supported.
                                            later on, all nuts filesystem protocols (implemented in NPath) including http,
                                            https, htmlfs (that supports tomcat and httpd/apache directory listing),
                                            dotfilefs, ssh and githubfs are supported.
                                            Remember that boot time repos are only used for installing nuts itself (and its
                                            dependencies).

 --yes | -y | --force
      disables interactive mode and assumes yes for all questions

 --no | -n
      disables interactive mode and assumes no for all questions

 --ask
      enables interactive mode

 --error
      exit with error whenever interactive mode is required


--desktop-launcher=never|unsupported|supported|preferred|always  (default depends on the operating system and the availability of a desktop environment)
   this option overrides default behaviour of the system
   desktop environment. It defines the support mode for desktop icons (application shortcut on the Desktop) for the desktop
   environment ( ##@see## NutsSupportMode class).
   ---system-desktop-launcher=unsupported disables creating any desktop icon on the system
   ---system-desktop-launcher=supported   enables creating desktop icons whenever asked by an application
   ---system-desktop-launcher=preferred   enables creating desktop icons whenever asked by an application and
                                                   that application requires this preference

---menu-launcher=never|unsupported|supported|preferred|always (default depends on the operating system and the availability of a desktop environment)
   this option overrides default behaviour of the system desktop environment.
   It defines the support mode for creating a menu for the desktop environment.

---user-launcher=never|unsupported|supported|preferred|always (default depends on the operating system and the availability of a desktop environment)
   this option overrides default behaviour of the system desktop environment.
   It defines the support mode for creating a custom application shortcut for the desktop environment.

 ) NUTS OPEN OPTIONS:

 --recover  or -z (defaults to false)
      try to recover from invalid workspace by ignoring cache and re-resolving dependencies. User configuration will not be altered.
      Will bootstrap workspace unless -Q (--skip-boot) option is armed.

 --reset  or -Z (defaults to false)
      reset (delete) nuts workspace folder before starting the workspace. All user configuration will not be deleted.

 --hard-reset (defaults to false)
      hard reset (delete) all of nuts workspaces and any configuration file. All user configuration will not be deleted.
      a common usage is to hard-reset nuts and exit using -Qy --hard-reset which will silently hard-reset configuration and exit.
      if -Q is not used, after resetting, a new workspace will be bootstrapping

 --skip-boot  or -Q (defaults to false)
      do not load workspace. This is helpful when used with --reset  or -Z, aka -QZ,  in which case,
      nuts is completely uninstalled from your system (called kill mode).

 --dry  or -D (defaults to false)
      perform a dry execution (with no side effects) rather than an effective one. prints actions or external command lines to
      perform if the --dry was not armed. Useful to know more about command effects.

 --skip-welcome  or -K (defaults to false)
      do not call welcome command if the command line is empty. This is helpful in conjunction with --reset not
      to start a new workspace (and recreate config files) after resetting the configuration folders.

 --embedded  or -b (defaults to false)
      when invoking a nuts artifact, it will be executed in the current process (no JVM process wil be spawn)

 --external  or --spawn or -x (defaults to true)
      when invoking a nuts artifact, it will always be executed in a newly created process (this is the default)

 --system (defaults to false)
 --user-cmd (deprecated, replaced by --system)
      the command is considered as a native command (not a nuts) and will be passed to the os as is.

 --current-user (defaults to true)
      the command is run as current user (default)

 --as-root   (defaults to false)
 --root-cmd (deprecated, replaced by --as-root)
      the command need to run with elevated privileges, aka as root (a password will be asked for if not already root).

 --run-as   (defaults to "")
      the command need to run with impersonation, aka as user  (a password will be asked for if not already ).

 --open-mode    (defaults to rw)
      defines open mode of the workspace. three values are accepted :
      open-or-create or rw or on or oc :
                    this is the default, if the workspace exists, it will be opened ;
                    if it is not it will be created then opened.
      open-existing or r   or o :
                    will open existing workspace of fail
      create-new or w or c or n :
                    will create non existing workspace of fail

 --open (defaults to false)
      will open existing workspace or fail if not already existing

 --create (defaults to false)
      will create non existing workspace or fail if already existing

 --open-or-create (defaults to true)
      will create non existing workspace or open if already existing

 --open-or-null (defaults to false)
      will open existing workspace or exit not already existing

 --theme  (defaults to default)
      start nuts using a specific terminal coloring theme.
      Current themes include:
        - default use default theme for the current environment
        - ansi    use ANSI colors
        - horizon used as default on linux and other NIX
        - grass   used as default on windows
        - any file path or url   : define your customized theme

---debug=port,(suspend|!suspend) this option enables running child processes with debug mode.
   It defaults to "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005" 
   Hence it runs by default in server mode, and using socket transport. If the port is not defined, it defaults to 5005.
   It the suspend mode is not defined it defaults to true.
   If this option is encountered as the very first argument, the root jvm process is also run in debug mode.
   nuts wil  use the first port available starting from the given port number.

###)  
NUTS NON STANDARD OPTIONS:



nuts provides extra, non standards options (aka susceptible to change in later versions).
Non standard options can be used by nuts or any nuts application. Such options start with three dashes
(and not two dashes).

---show-command prints child process command arguments
---monitor-start prints a message when starting a new monitor


###)  
SPECIAL OPTIONS:


--version  [<-options>]...
 or -version or -v
      show api version and exit without loading the workspace
      for more details, type : nuts version version

 --help  [<-options>]...
 or -help or -h
      show a short message describing nuts and exit without loading the workspace
      for more details, type : nuts help

##)  
NUTS COMMAND:


nuts handles a set of command to manage nuts it sel and to run/exec other programs, mainly those its was responsible
for installing. Commands support include internal commands, supported packages (installed or not, when not installed
will search for it), aliases (a commodity mechanism to extend internal commands) and even any other executable.
 Here is a lis of internal commands :

 version  [<-options>]...
      load workspace and show api and runtime versions, then exit

 info  [<-options>]...
      show workspace detailed information (paths and libraries) and exit.
      for more details, type : nuts help info

 welcome  [<-options>]...
      show welcome message and exit.
      for more details, type : nuts help welcome

 help  [<-options>]... ...
 or --help or -? or -h
      show this help and exit
      for more details, type : nuts help help

 license [<-options>]...
      show license info and exit
      for more details, type : nuts help info

 install [<-options>]... ...  ...
      install nuts package 
      for more details, type : nuts help install

 uninstall [<-options>]... ...  ...
      uninstall  nuts package 
      for more details, type : nuts help uninstall

 update [<-options>]...  ...   ...
      check if a newer version of nuts or any of the provided 
      is available in the current workspace and perform update by downloading (fetch)
      and installing the artifact. The updated version is promoted to 'default' version.
      for more details, type : nuts help update
            
 check-updates [<-options>]...  ...
      check if a newer version of nuts is available in the current workspace without performing updates
      Takes the same arguments and options as update command
      for more details, type : nuts help check-updates

 search [<-options>]...  ...
      search for 
      for more details, type : nuts help search
            
 fetch [<-options>]...  ...
      download   without installing them
      for more details, type : nuts help fetch
            
 deploy [<-options>]...  ...
      deploy   without installing them
      for more details, type : nuts help deploy
            
 undeploy [<-options>]...  ...
      undeploy 
      for more details, type : nuts help undeploy
            
 exec [<-options>]... [command] ...
 --exec [<-options>]... [command] ...
 -e [<-options>]... [command] ...
      run command with the given executor options ( it will be considered an option if it
      starts with - ). This is helpful to issue JVM Options to executor for instance.
      for more details, type : nuts help exec

 which [<-options>]... [command] ...
      show command to be executed if run with 'exec' 
      for more details, type : nuts help which
            
 - ...
   run a nuts shell nsh command with the remaining arguments.
   This is equivalent to nsh -c 



##)  
EXAMPLES:


nuts help
            show this help and exit
       
nuts help exec
            show help for the exec command, equivalent to nuts exec --help

nuts --workspace /home/me/some-folder --archetype=minimal 
            a minimal (minimal archetype) workspace will be created
            and saved if no workspace was resolved. The workspace handles local 
            packages only
       
nuts --workspace /home/me/some-folder  update 
            updates nuts to the very latest version using workspace location
            /home/me/some-folder.

        nuts --workspace /home/me/some-folder  --yes -e -Xmx1G netbeans-launcher
            run netbeans-launcher with JVM option -Xmx1G. If the artifact is not installed
            it will be automatically installed ( --yes modifier helps disabling interactive mode)

nuts -Zy -w test -P=%n
            force progress to use newline after each message instead of updating the same line while using test workspace

nuts -ZSby ---system-desktop-launcher=preferred
            run nuts and prefer creating launcher icons when asked for by apps regardless of system defaults.

nuts -ZQ -w=test --json
            reset workspace test and show result in json format

nuts -ZySb -w=test --theme=documentation/website/static/theme-examples/min2.ntf-theme
            run nuts with a custom theme file.
            Examples of theme files are available under $nuts_github/website/static/theme-examples/


nuts - ls
            run the ls command using nsh (aka nuts nsh -c ls)

nuts ls
            run the ls command (either defined as a custom command or system command).
            Note that installing nsh will also install somme custom commands, including ls
            which refers to nsh -c ls, too

###)  
special command native-exec


Nuts Boot can be used to run native commands by using native-exec as very first argument.
native-exec allows running any command until it exits without error (zero status) or a maximum run count is reached

nuts native-exec ... ...

 --min-time= (defaults to 0ms)
      if the running command exits before min-time, the application ends with error
      time can be suffixed with 'ms' (for milliseconds) or 's' for seconds

 --wait-time= (defaults to 0ms)
      time to wait before rerunning the same command
      time can be suffixed with 'ms' (for milliseconds) or 's' for seconds


 --max-count= (defaults to 1)
      if the running command exits before min-time, the application ends with error
      time can be suffixed with 'ms' (for milliseconds) or 's' for seconds

##)  
ncode:


simple file/java class finder (incubating)

###)  
SYNOPSIS:


ncode  ...
 

ncode -[!][i]t name [folder/file-list] 
find java type with name 'name' in folder/file list

ncode -[!][i]f name [folder/file-list]
find file with path 'name' in folder/file list

###)  
EXAMPLES:


ncode -t String . foo.zip
search for type which name contains 'String' (case sensitive) in folders . and foo.zip
ncode -it String . foo.zip
search for type which name contains 'String' or 'STRING' (case insensitive) in both folder . and foo.zip
ncode -t ^java.lang.String$ . foo.zip
search for type which exact name 'java.lang.String' in folder . and file foo.zip

##)  
ndiff:


diff folders/files/jars (incubating)

###)  
SYNOPSIS:


ndiff  
 

show differences

***) EXAMPLE

nuts ndiff my-app-v1.jar my-app-v2.jar

ndoc is a documentation tool

`ndoc` is a simple templating tool. It is used to generate statically Nuts website from
markdown documents.
`ndoc` can also be embedded as a library (as `net.thevpc.nuts.lib:nlib-doc#0.8.5.0`)

 INSTALL

nuts install ndoc


##) EXAMPLE OF USAGE

nuts ndoc --source your-folder  --target the-generated-folder


) SYNOPSYS

nuts ndoc (--source=)+ (--resource=)* --target= ()*


Options are :

- `-s=<...>` ou `--source=<...>` :  source file or folder to process.
- `--resource=<...>` :         source file or folder that are copied as is and are not processed by the template engine.
- `-t=<...>` ou `--target=<...>` : target folder where the generated files will be located

 Templating format ()
    {{: statement}}
    {{expression}}
    {{:for varName(,index):
    {{:if expression}} ... {{:else if expression}} ... {{:else if expression}} {{:end}}




##) SYNOPSIS:


-Zy -w test ndoc --progress=none --skip-errors -bZKy ndoc --backend=docusaurus --source /data/git/nuts/core/nuts --target /data/git/nuts/documentation/website/docs/javadocs
    generate javadoc

==ntemplate== generate files and forlder from template file/folder

##) EXAMPLES:

# ndoc: generate folder
nuts -Zy -w test ntemplate --progress=none --skip-errors -bZy ntemplate -p $ProjectFileDir$/dir-template

##)  
njob:


is a productivity tool to follow you tasks

###)  
INSTALL


nuts install njob


###)  
EXAMPLE OF USAGE



nuts njob tasks add 'I will buy milk' --on afternoon


###)  
SYNOPSIS:


njob tasks | jobs | projects | summary...
    manage tasks, jobs, projects
    a project aggregates multiple jobs
    a job aggregates multiple tasks
    a task has a status and priority

T0008- DB Commandline Tool

T0012- Nuts Diff (Jar Diff Tool)

T0006- Docusaurus (Templater Companion for Facebook's Docusaurus)

T0010- Maven (Maven Build Tool)

T0005- Nuts Open Api (Open Api Pdf Generator)

T0001- Nuts shell (Bash compatible Shell)

T0002- Nuts Version (File/Folder/Project version detector)

T0014- Spring Cli (Spring Boot Client App)

T0016- Google Tsunami (Security Scanner)

dbclient (Jdbc client)

  nuts install dbclient
# Example of usage
  nuts dbclient

G0006- kifkif (File/Folder Duplicates finder)

  nuts install kifkif
# Example of usage
  nuts kifkif

G0001- Netbeans Launcher (Netbeans IDE multi-workspace Launcher)

nuts install netbeans-launcher
# Example of usage
nuts netbeans-launcher

• G0002- Pangaea Note (Note Taking Application)

Install

nuts install pnote

Run

nuts pnote

Install

nuts install eu.binjr:binjr-core

Run

nuts binjr-core

G0011- Java Decompiler GUI (Java Decompiler)

  nuts install org.jd:jd-gui
# Example of usage
  nuts jd-gui

G0014- JDiskReport (Disk Usage Utility)

  nuts install com.jgoodies:jdiskreport
# Example of usage
  nuts jdiskreport

G0009- jedit (JEdit Text Editor)

  nuts install org.jedit:jedit
# Example of usage
  nuts jedit

G0009- JMeld (A visual diff and merge tool)

  nuts install org.jmeld:jmeld
# Example of usage
  nuts jmeld

G0007- jpass (Password app)

  nuts install jpass:jpass
# Example of usage
  nuts jpass

• G0010- mucommander (File Manager)

  nuts install com.mucommander:mucommander
# Example of usage
  nuts mucommander

G0005- OmegaT (Translation Tool)

nuts install org.omegat:omegat
# Example of usage
nuts omegat

G0008- omnigraph (Graph Editor)

  nuts install com.github.todense:omnigraph
# Example of usage
  nuts omnigraph

Install

  nuts install io.github.jiashunx:masker-flappybird

Run

  nuts masker-flappybird

Mindustry Game

• G0013- Mindustry Desktop (Game)

  nuts install com.github.anuken:mindustry-desktop
# Example of usage
  nuts mindustry-desktop

• G0013- Mindustry Server (Game Server)

  nuts install com.github.anuken:mindustry-server
# Example of usage
  nuts mindustry-server

T0004- Nuts Repository (Nuts Repository Server)

nuts install nserver
# Example of usage
nuts nserver --http

T0007- Tomcat Web Sever

nuts install ntomcat
# Example of usage
nuts ntomcat --start