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 


 

##)  
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`)

##)  
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