Bump to 0.40 (#4129)

* Add 'detect columns' command

* Fix warnings

.azure/azure-pipelines.yml

@@ -1,28 +1,28 @@
 trigger:
-  - master
+  - main
 
 strategy:
   matrix:
-    linux-nightly:
-      image: ubuntu-16.04
+    linux-stable:
+      image: ubuntu-18.04
       style: 'unflagged'
-    macos-nightly:
+    linux-minimal:
+      image: ubuntu-18.04
+      style: 'minimal'
+    linux-extra:
+      image: ubuntu-18.04
+      style: 'extra'
+    linux-wasm:
+      image: ubuntu-18.04
+      style: 'wasm'
+    macos-stable:
       image: macos-10.14
       style: 'unflagged'
-    windows-nightly:
-      image: vs2017-win2016
+    windows-stable:
+      image: windows-2019
       style: 'unflagged'
-    linux-nightly-canary:
-      image: ubuntu-16.04
-      style: 'canary'
-    macos-nightly-canary:
-      image: macos-10.14
-      style: 'canary'
-    windows-nightly-canary:
-      image: vs2017-win2016
-      style: 'canary'
     fmt:
-      image: ubuntu-16.04
+      image: ubuntu-18.04
       style: 'fmt'
 
 pool:
@@ -35,17 +35,31 @@ steps:
       then
         sudo apt-get -y install libxcb-composite0-dev libx11-dev
       fi
-      curl https://sh.rustup.rs -sSf | sh -s -- -y --no-modify-path --default-toolchain `cat rust-toolchain`
-      export PATH=$HOME/.cargo/bin:$PATH
-      rustc -Vv
-      echo "##vso[task.prependpath]$HOME/.cargo/bin"
-      rustup component add rustfmt --toolchain `cat rust-toolchain`
+      if [ "$(uname)" == "Darwin" ]; then
+        curl https://sh.rustup.rs -sSf | sh -s -- -y --no-modify-path --default-toolchain "stable"
+        echo "Installing clippy"
+        rustup component add clippy --toolchain stable-x86_64-apple-darwin
+        export PATH=$HOME/.cargo/bin:$PATH
+      fi
+  #     rustup update
+  #     rustc -Vv
+  #     echo "##vso[task.prependpath]$HOME/.cargo/bin"
+  #     rustup component add rustfmt
     displayName: Install Rust
-  - bash: RUSTFLAGS="-D warnings" cargo test --all-features
+  - bash: RUSTFLAGS="-D warnings" cargo test --all
     condition: eq(variables['style'], 'unflagged')
     displayName: Run tests
-  - bash: NUSHELL_ENABLE_ALL_FLAGS=1 RUSTFLAGS="-D warnings" cargo test --all-features
-    condition: eq(variables['style'], 'canary')
+  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used -A clippy::needless_collect
+    condition: eq(variables['style'], 'unflagged')
+    displayName: Check clippy lints
+  - bash: cd samples/wasm && npm install wasm-pack && node ./node_modules/wasm-pack/run.js build
+    condition: eq(variables['style'], 'wasm')
+    displayName: Wasm build
+  - bash: RUSTFLAGS="-D warnings" cargo test --all --no-default-features --features=rustyline-support
+    condition: eq(variables['style'], 'minimal')
+    displayName: Run tests
+  - bash: RUSTFLAGS="-D warnings" cargo test --all --features=extra
+    condition: eq(variables['style'], 'extra')
     displayName: Run tests
   - bash: cargo fmt --all -- --check
     condition: eq(variables['style'], 'fmt')

.cargo/config.toml

@@ -0,0 +1,6 @@
+# use LLD as linker on Windows because it could be faster
+# for full and incremental builds compared to default
+
+[target.x86_64-pc-windows-msvc]
+#linker = "lld-link.exe"
+rustflags = ["-C", "link-args=-stack:10000000"]

.circleci/config.yml

@@ -27,7 +27,7 @@ orbs:
 workflows:
   version: 2.0
 
-  # This builds on all pull requests to test, and ignores master
+  # This builds on all pull requests to test, and ignores main
   build_without_deploy:
     jobs:
       - docker/publish:
@@ -38,8 +38,8 @@ workflows:
           extra_build_args: --cache-from=quay.io/nushell/nu-base:devel
           filters:
             branches:
-              ignore: 
-                - master
+              ignore:
+                - main
           before_build:
             - pull_cache
           after_build:
@@ -73,7 +73,7 @@ workflows:
             branches:
               ignore: /.*/
             tags:
-              only: /^v.*/
+              only: /^\d+\.\d+\.\d+$/
           before_build:
             - run: docker pull quay.io/nushell/nu:latest
             - run: docker pull quay.io/nushell/nu-base:latest
@@ -98,11 +98,11 @@ workflows:
                    docker push quay.io/nushell/nu
 
 
-  # publish devel to Docker Hub on merge to master (doesn't build --release)
+  # publish devel to Docker Hub on merge to main (doesn't build --release)
   build_with_deploy_devel:
     jobs:
 
-      # Deploy devel tag on merge to master
+      # Deploy devel tag on merge to main
       - docker/publish:
           image: nushell/nu-base
           registry: quay.io
@@ -113,7 +113,7 @@ workflows:
             - pull_cache
           filters:
             branches:
-              only: master
+              only: main
           after_build:
             - run:
                 name: Build Multistage (smaller) container
@@ -137,7 +137,7 @@ workflows:
           filters:
             branches:
               only:
-                - master
+                - main
     jobs:
       - docker/publish:
           image: nushell/nu-base

.dockerignore

@@ -0,0 +1 @@
+target

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,65 @@
+name: Bug Report
+description: Create a report to help us improve
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of what the bug is.
+    validations:
+      required: true
+  - type: textarea
+    id: repro
+    attributes:
+      label: How to reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        1.
+        2.
+        3.
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: A clear and concise description of what you expected to happen.
+      placeholder: I expected nu to...
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: Please add any relevant screenshots here, if any
+    validations:
+      required: false
+  - type: textarea
+    id: config
+    attributes:
+      label: Configuration
+      description: "Please run `> version | pivot key value | to md` and paste the output to show OS, features, etc"
+      placeholder: |
+        > version | pivot key value | to md
+        ╭───┬────────────────────┬───────────────────────────────────────────────────────────────────────╮
+        │ # │ key                │ value                                                                 │
+        ├───┼────────────────────┼───────────────────────────────────────────────────────────────────────┤
+        │ 0 │ version            │ 0.24.1                                                                │
+        │ 1 │ build_os           │ macos-x86_64                                                          │
+        │ 2 │ rust_version       │ rustc 1.48.0                                                          │
+        │ 3 │ cargo_version      │ cargo 1.48.0                                                          │
+        │ 4 │ pkg_version        │ 0.24.1                                                                │
+        │ 5 │ build_time         │ 2020-12-18 09:54:09                                                   │
+        │ 6 │ build_rust_channel │ release                                                               │
+        │ 7 │ features           │ ctrlc, default, directories, dirs, git, ichwh, rich-benchmark,        │
+        │   │                    │ rustyline, term, uuid, which, zip                                     │
+        ╰───┴────────────────────┴───────────────────────────────────────────────────────────────────────╯
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,34 @@
+name: Feature Request
+description: "When you want a new feature for something that doesn't already exist"
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: Related problem
+      description: Is your feature request related to a problem? Please describe.
+      placeholder: |
+        A clear and concise description of what the problem is.
+        Example: I am trying to do [...] but [...]
+    validations:
+      required: false
+  - type: textarea
+    id: desired
+    attributes:
+      label: "Describe the solution you'd like"
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: "Describe alternatives you've considered"
+      description: "A clear and concise description of any alternative solutions or features you've considered."
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context and details
+      description: Add any other context or screenshots about the feature request here.
+    validations:
+      required: false

.github/workflows/docker-publish.yml

@@ -1,98 +0,0 @@
-name: Publish consumable Docker images
-
-on:
-  push:
-    tags: ['*.*.*']
-
-jobs:
-  compile:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        arch:
-        - x86_64-unknown-linux-musl
-        - x86_64-unknown-linux-gnu
-    steps:
-    - uses: actions/checkout@v1
-    - run: cargo install cross
-    - name: compile for specific target
-      env: { arch: '${{ matrix.arch }}' }
-      run: |
-        cross build --target ${{ matrix.arch }} --release
-        # leave only the executable file
-        rm -rd target/${{ matrix.arch }}/release/{*/*,*.d,*.rlib,.fingerprint}
-        find . -empty -delete
-    - uses: actions/upload-artifact@master
-      with:
-        name: ${{ matrix.arch }}
-        path: target/${{ matrix.arch }}/release
-
-  docker:
-    name: Build and publish docker images
-    needs: compile
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        tag:
-        - alpine
-        - slim
-        - debian
-        - glibc-busybox
-        - musl-busybox
-        - musl-distroless
-        - glibc-distroless
-        - glibc
-        - musl
-        include:
-        - { tag: alpine,           base-image: alpine,                     arch: x86_64-unknown-linux-musl, plugin: true    }
-        - { tag: slim,             base-image: 'debian:stable-slim',       arch: x86_64-unknown-linux-gnu,  plugin: true    }
-        - { tag: debian,           base-image: debian,                     arch: x86_64-unknown-linux-gnu,  plugin: true    }
-        - { tag: glibc-busybox,    base-image: 'busybox:glibc',            arch: x86_64-unknown-linux-gnu,  use-patch: true }
-        - { tag: musl-busybox,     base-image: 'busybox:musl',             arch: x86_64-unknown-linux-musl,                 }
-        - { tag: musl-distroless,  base-image: 'gcr.io/distroless/static', arch: x86_64-unknown-linux-musl,                 }
-        - { tag: glibc-distroless, base-image: 'gcr.io/distroless/cc',     arch: x86_64-unknown-linux-gnu,  use-patch: true }
-        - { tag: glibc,            base-image: scratch,                    arch: x86_64-unknown-linux-gnu,                  }
-        - { tag: musl,             base-image: scratch,                    arch: x86_64-unknown-linux-musl,                 }
-    steps:
-    - uses: actions/checkout@v1
-    - uses: actions/download-artifact@master
-      with: { name: '${{ matrix.arch }}', path: target/release }
-    - name: Build and publish exact version
-      run: |
-        REGISTRY=${REGISTRY,,}; export TAG=${GITHUB_REF##*/}-${{ matrix.tag }};
-        export NU_BINS=target/release/$( [ ${{ matrix.plugin }} = true ] && echo nu* || echo nu )
-        export PATCH=$([ ${{ matrix.use-patch }} = true ] && echo .${{ matrix.tag }} || echo '')
-        chmod +x $NU_BINS
-
-        echo ${{ secrets.DOCKER_REGISTRY }} | docker login docker.pkg.github.com -u ${{ github.actor }} --password-stdin
-        docker-compose --file docker/docker-compose.package.yml build
-        docker-compose --file docker/docker-compose.package.yml push              # exact version
-      env:
-        BASE_IMAGE: ${{ matrix.base-image }}
-        REGISTRY: docker.pkg.github.com/${{ github.repository }}
-
-    #region semantics tagging
-    - name: Retag and push without suffixing version
-      run: |
-        VERSION=${GITHUB_REF##*/}
-        docker tag ${REGISTRY,,}/nu:${VERSION}-${{ matrix.tag }} ${REGISTRY,,}/nu:${{ matrix.tag }}
-        docker tag ${REGISTRY,,}/nu:${VERSION}-${{ matrix.tag }} ${REGISTRY,,}/nu:${VERSION%%.*}-${{ matrix.tag }}
-        docker tag ${REGISTRY,,}/nu:${VERSION}-${{ matrix.tag }} ${REGISTRY,,}/nu:${VERSION%.*}-${{ matrix.tag }}
-        docker push ${REGISTRY,,}/nu:${VERSION%.*}-${{ matrix.tag }}              # latest patch
-        docker push ${REGISTRY,,}/nu:${VERSION%%.*}-${{ matrix.tag }}             # latest features
-        docker push ${REGISTRY,,}/nu:${{ matrix.tag }}                            # latest version
-      env: { REGISTRY: 'docker.pkg.github.com/${{ github.repository }}' }
-    - name: Retag and push debian as latest
-      if: matrix.tag == 'debian'
-      run: |
-        VERSION=${GITHUB_REF##*/}
-        docker tag ${REGISTRY,,}/nu:${{ matrix.tag }} ${REGISTRY,,}/nu:latest
-        docker tag ${REGISTRY,,}/nu:${VERSION}-${{ matrix.tag }} ${REGISTRY,,}/nu:${VERSION%.*}
-        docker tag ${REGISTRY,,}/nu:${VERSION}-${{ matrix.tag }} ${REGISTRY,,}/nu:${VERSION%%.*}
-        docker tag ${REGISTRY,,}/nu:${VERSION}-${{ matrix.tag }} ${REGISTRY,,}/nu:${VERSION}
-        docker push ${REGISTRY,,}/nu:${VERSION}       # exact version
-        docker push ${REGISTRY,,}/nu:${VERSION%%.*}   # latest features
-        docker push ${REGISTRY,,}/nu:${VERSION%.*}    # latest patch
-        docker push ${REGISTRY,,}/nu:latest           # latest version
-      env: { REGISTRY: 'docker.pkg.github.com/${{ github.repository }}' }
-    #endregion semantics tagging

.github/workflows/release.yml

@@ -0,0 +1,557 @@
+name: Create Release Draft
+
+on:
+  workflow_dispatch:
+  push:
+    tags: ['[0-9]+.[0-9]+.[0-9]+*']
+
+jobs:
+  linux:
+    name: Build Linux
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v2
+
+      - name: Install libxcb
+        run: sudo apt-get install libxcb-composite0-dev
+
+      - name: Set up cargo
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+
+      - name: Build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --release --all --features=extra
+
+      - name: Compress binaries (nu)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu
+
+      - name: Compress binaries (nu_plugin_inc)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_inc
+        
+      - name: Compress binaries (nu_plugin_match)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_match
+
+      - name: Compress binaries (nu_plugin_textview)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_textview
+          
+      - name: Compress binaries (nu_plugin_binaryview)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_binaryview
+        
+      - name: Compress binaries (nu_plugin_chart_bar)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_chart_bar
+        
+      - name: Compress binaries (nu_plugin_chart_line)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_chart_line
+
+      - name: Compress binaries (nu_plugin_from_bson)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_from_bson
+        
+      - name: Compress binaries (nu_plugin_from_sqlite)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_from_sqlite
+
+      - name: Compress binaries (nu_plugin_from_mp4)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_from_mp4
+          
+      - name: Compress binaries (nu_plugin_query_json)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_query_json
+          
+      - name: Compress binaries (nu_plugin_s3)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_s3
+        
+      - name: Compress binaries (nu_plugin_selector)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_selector
+        
+      - name: Compress binaries (nu_plugin_start)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_start
+                
+      - name: Compress binaries (nu_plugin_to_bson)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_to_bson
+        
+      - name: Compress binaries (nu_plugin_to_sqlite)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_to_sqlite
+        
+      - name: Compress binaries (nu_plugin_tree)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_tree
+        
+      - name: Compress binaries (nu_plugin_xpath)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_xpath
+                  
+      - name: Create output directory
+        run: mkdir output
+
+      - name: Copy files to output
+        run: |
+          cp target/release/nu target/release/nu_plugin_* output/
+          cp README.build.txt output/README.txt
+          cp LICENSE output/LICENSE
+          rm output/*.d
+          rm output/nu_plugin_core_*
+          rm output/nu_plugin_extra_*
+
+      # Note: If OpenSSL changes, this path will need to be updated
+      - name: Copy OpenSSL to output
+        run: cp /usr/lib/x86_64-linux-gnu/libssl.so.1.1 output/
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: linux
+          path: output/*
+
+  macos:
+    name: Build macOS
+    runs-on: macos-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v2
+
+      - name: Set up cargo
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+
+      - name: Build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --release --all --features=extra
+
+      - name: Compress binaries (nu)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu
+
+      - name: Compress binaries (nu_plugin_inc)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_inc
+        
+      - name: Compress binaries (nu_plugin_match)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_match
+
+      - name: Compress binaries (nu_plugin_textview)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_textview
+          
+      - name: Compress binaries (nu_plugin_binaryview)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_binaryview
+        
+      - name: Compress binaries (nu_plugin_chart_bar)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_chart_bar
+        
+      - name: Compress binaries (nu_plugin_chart_line)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_chart_line
+
+      - name: Compress binaries (nu_plugin_from_bson)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_from_bson
+        
+      - name: Compress binaries (nu_plugin_from_sqlite)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_from_sqlite
+
+      - name: Compress binaries (nu_plugin_from_mp4)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_from_mp4
+          
+      - name: Compress binaries (nu_plugin_query_json)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_query_json
+          
+      - name: Compress binaries (nu_plugin_s3)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_s3
+        
+      - name: Compress binaries (nu_plugin_selector)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_selector
+        
+      - name: Compress binaries (nu_plugin_start)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_start
+                
+      - name: Compress binaries (nu_plugin_to_bson)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_to_bson
+        
+      - name: Compress binaries (nu_plugin_to_sqlite)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_to_sqlite
+        
+      - name: Compress binaries (nu_plugin_tree)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_tree
+        
+      - name: Compress binaries (nu_plugin_xpath)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_xpath
+
+      - name: Create output directory
+        run: mkdir output
+
+      - name: Copy files to output
+        run: |
+          cp target/release/nu target/release/nu_plugin_* output/
+          cp README.build.txt output/README.txt
+          cp LICENSE output/LICENSE
+          rm output/*.d
+          rm output/nu_plugin_core_*
+          rm output/nu_plugin_extra_*
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: macos
+          path: output/*
+
+  windows:
+    name: Build Windows
+    runs-on: windows-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v2
+
+      - name: Set up cargo
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+
+      - name: Add cargo-wix subcommand
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-wix
+
+      - name: Build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --release --all --features=extra
+
+      - name: Compress binaries (nu.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu.exe
+
+      - name: Compress binaries (nu_plugin_inc.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_inc.exe
+        
+      - name: Compress binaries (nu_plugin_match.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_match.exe
+
+      - name: Compress binaries (nu_plugin_textview.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_textview.exe
+          
+      - name: Compress binaries (nu_plugin_binaryview.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_binaryview.exe
+        
+      - name: Compress binaries (nu_plugin_chart_bar.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_chart_bar.exe
+        
+      - name: Compress binaries (nu_plugin_chart_line.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_chart_line.exe
+
+      - name: Compress binaries (nu_plugin_from_bson.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_from_bson.exe
+        
+      - name: Compress binaries (nu_plugin_from_sqlite.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_from_sqlite.exe
+
+      - name: Compress binaries (nu_plugin_from_mp4.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_from_mp4.exe
+          
+      - name: Compress binaries (nu_plugin_query_json.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_query_json.exe
+          
+      - name: Compress binaries (nu_plugin_s3.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_s3.exe
+        
+      - name: Compress binaries (nu_plugin_selector.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_selector.exe
+        
+      - name: Compress binaries (nu_plugin_start.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_start.exe
+                
+      - name: Compress binaries (nu_plugin_to_bson.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_to_bson.exe
+        
+      - name: Compress binaries (nu_plugin_to_sqlite.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_to_sqlite.exe
+        
+      - name: Compress binaries (nu_plugin_tree.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_tree.exe
+        
+      - name: Compress binaries (nu_plugin_xpath.exe)
+        uses: svenstaro/upx-action@v2
+        with:
+          file: target/release/nu_plugin_xpath.exe
+
+      - name: Create output directory
+        run: mkdir output
+
+      - name: Download Less Binary
+        run: Invoke-WebRequest -Uri "https://github.com/jftuga/less-Windows/releases/download/less-v562.0/less.exe" -OutFile "target\release\less.exe"
+
+      - name: Download Less License
+        run: Invoke-WebRequest -Uri "https://raw.githubusercontent.com/jftuga/less-Windows/master/LICENSE" -OutFile "target\release\LICENSE-for-less.txt"
+
+      - name: Copy files to output
+        run: |
+          cp target\release\nu.exe output\
+          cp LICENSE output\
+          cp target\release\LICENSE-for-less.txt output\
+          rm target\release\nu_plugin_core_*.exe
+          rm target\release\nu_plugin_extra_*.exe
+          cp target\release\nu_plugin_*.exe output\
+          cp README.build.txt output\README.txt
+          cp target\release\less.exe output\
+      # Note: If the version of `less.exe` needs to be changed, update this URL
+      # Similarly, if `less.exe` is checked into the repo, copy from the local path here
+      # moved this stuff down to create wix after we download less
+
+      - name: Create msi with wix
+        uses: actions-rs/cargo@v1
+        with:
+          command: wix
+          args: --no-build --nocapture --output target\wix\nushell-windows.msi
+
+      - name: Upload installer
+        uses: actions/upload-artifact@v2
+        with:
+          name: windows-installer
+          path: target\wix\nushell-windows.msi
+
+      - name: Upload zip
+        uses: actions/upload-artifact@v2
+        with:
+          name: windows-zip
+          path: output\*
+
+  release:
+    name: Publish Release
+    runs-on: ubuntu-latest
+    needs:
+      - linux
+      - macos
+      - windows
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v2
+
+      - name: Determine Release Info
+        id: info
+        env:
+          GITHUB_REF: ${{ github.ref }}
+        run: |
+          VERSION=${GITHUB_REF##*/}
+          MAJOR=${VERSION%%.*}
+          MINOR=${VERSION%.*}
+          MINOR=${MINOR#*.}
+          PATCH=${VERSION##*.}
+          echo "::set-output name=version::${VERSION}"
+          echo "::set-output name=linuxdir::nu_${MAJOR}_${MINOR}_${PATCH}_linux"
+          echo "::set-output name=macosdir::nu_${MAJOR}_${MINOR}_${PATCH}_macOS"
+          echo "::set-output name=windowsdir::nu_${MAJOR}_${MINOR}_${PATCH}_windows"
+          echo "::set-output name=innerdir::nushell-${VERSION}"
+
+      - name: Create Release Draft
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: ${{ steps.info.outputs.version }} Release
+          draft: true
+
+      - name: Create Linux Directory
+        run: mkdir -p ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}
+
+      - name: Download Linux Artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: linux
+          path: ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}
+
+      - name: Restore Linux File Modes
+        run: |
+          chmod 755 ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}/nu*
+          chmod 755 ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}/libssl*
+
+      - name: Create Linux tarball
+        run: tar -zcvf ${{ steps.info.outputs.linuxdir }}.tar.gz ${{ steps.info.outputs.linuxdir }}
+
+      - name: Upload Linux Artifact
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./${{ steps.info.outputs.linuxdir }}.tar.gz
+          asset_name: ${{ steps.info.outputs.linuxdir }}.tar.gz
+          asset_content_type: application/gzip
+
+      - name: Create macOS Directory
+        run: mkdir -p ${{ steps.info.outputs.macosdir }}/${{ steps.info.outputs.innerdir }}
+
+      - name: Download macOS Artifacts
+        uses: actions/download-artifact@v2
+        with:
+          name: macos
+          path: ${{ steps.info.outputs.macosdir }}/${{ steps.info.outputs.innerdir }}
+
+      - name: Restore macOS File Modes
+        run: chmod 755 ${{ steps.info.outputs.macosdir }}/${{ steps.info.outputs.innerdir }}/nu*
+
+      - name: Create macOS Archive
+        run: zip -r ${{ steps.info.outputs.macosdir }}.zip ${{ steps.info.outputs.macosdir }}
+
+      - name: Upload macOS Artifact
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./${{ steps.info.outputs.macosdir }}.zip
+          asset_name: ${{ steps.info.outputs.macosdir }}.zip
+          asset_content_type: application/zip
+
+      - name: Create Windows Directory
+        run: mkdir -p ${{ steps.info.outputs.windowsdir }}/${{ steps.info.outputs.innerdir }}
+
+      - name: Download Windows zip
+        uses: actions/download-artifact@v2
+        with:
+          name: windows-zip
+          path: ${{ steps.info.outputs.windowsdir }}/${{ steps.info.outputs.innerdir }}
+
+      - name: Show Windows Artifacts
+        run: ls -la ${{ steps.info.outputs.windowsdir }}/${{ steps.info.outputs.innerdir }}
+
+      - name: Create macOS Archive
+        run: zip -r ${{ steps.info.outputs.windowsdir }}.zip ${{ steps.info.outputs.windowsdir }}
+
+      - name: Upload Windows zip
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./${{ steps.info.outputs.windowsdir }}.zip
+          asset_name: ${{ steps.info.outputs.windowsdir }}.zip
+          asset_content_type: application/zip
+
+      - name: Download Windows installer
+        uses: actions/download-artifact@v2
+        with:
+          name: windows-installer
+          path: ./
+          
+      - name: Upload Windows installer
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./nushell-windows.msi
+          asset_name: ${{ steps.info.outputs.windowsdir }}.msi
+          asset_content_type: application/x-msi

.github/workflows/stale.yml

@@ -0,0 +1,28 @@
+name: 'Close stale issues and PRs'
+#on: [workflow_dispatch]
+on:
+  schedule:
+    - cron: '30 1 * * *'
+
+permissions:
+  issues: write
+  pull-requests: write
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v3
+        with:
+          #debug-only: true
+          ascending: true
+          operations-per-run: 520
+          enable-statistics: true
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          close-issue-message: 'This issue has been marked stale for more than 100000 days without activity. Closing this issue, but if you find that the issue is still valid, please reopen.'
+          close-pr-message: 'This PR has been marked stale for more than 100 days without activity. Closing this PR, but if you are still working on it, please reopen.'
+          days-before-issue-stale: 90
+          days-before-pr-stale: 45
+          days-before-issue-close: 100000
+          days-before-pr-close: 100
+          exempt-issue-labels: 'exempt,keep'

.github/workflows/winget-submission.yml

@@ -0,0 +1,18 @@
+name: Submit Nushell package to Windows Package Manager Community Repository 
+
+on:
+  release:
+    types: [published]
+
+jobs:
+
+  winget:
+    name: Publish winget package
+    runs-on: windows-latest
+    steps:
+      - name: Submit package to Windows Package Manager Community Repository
+        run: |
+          iwr https://aka.ms/wingetcreate/latest -OutFile wingetcreate.exe
+          $github = Get-Content '${{ github.event_path }}' | ConvertFrom-Json
+          $installerUrl = $github.release.assets | Where-Object -Property name -match 'windows.msi' | Select -ExpandProperty browser_download_url -First 1
+          .\wingetcreate.exe update Nushell.Nushell -s -v $github.release.tag_name -u $installerUrl -t ${{ secrets.NUSHELL_PAT }}

.gitignore

@@ -3,6 +3,7 @@
 **/*.rs.bk
 history.txt
 tests/fixtures/nuplayground
+crates/*/target
 
 # Debian/Ubuntu
 debian/.debhelper/
@@ -10,3 +11,12 @@ debian/debhelper-build-stamp
 debian/files
 debian/nu.substvars
 debian/nu/
+
+# macOS junk
+.DS_Store
+
+# JetBrains' IDE items
+.idea/*
+
+# VSCode's IDE items
+.vscode/*

.gitpod.Dockerfile

@@ -1,7 +1,18 @@
 FROM gitpod/workspace-full
-USER root
-RUN apt-get update && apt-get install -y libssl-dev \
-    libxcb-composite0-dev \
-    pkg-config \
-    curl \
-    rustc
+
+# Gitpod will not rebuild Nushell's dev image unless *some* change is made to this Dockerfile.
+# To force a rebuild, simply increase this counter:
+ENV TRIGGER_REBUILD 2
+
+USER gitpod
+
+RUN sudo apt-get update && \
+    sudo apt-get install -y \
+        libssl-dev \
+        libxcb-composite0-dev \
+        pkg-config \
+        libpython3.6 \
+        rust-lldb \
+    && sudo rm -rf /var/lib/apt/lists/*
+
+ENV RUST_LLDB=/usr/bin/lldb-11

.gitpod.yml

@@ -1,21 +1,25 @@
 image:
   file: .gitpod.Dockerfile
 tasks:
-  - init: cargo build
-    command: cargo run
+  - name: Clippy
+    init: cargo clippy --all --features=stable -- -D clippy::result_unwrap_used -D clippy::option_unwrap_used
+  - name: Testing
+    init: cargo test --all --features=stable
+  - name: Build
+    init: cargo build --features=stable
+  - name: Nu
+    init: cargo install --path . --features=stable
+    command: nu
 github:
   prebuilds:
-    # enable for the master/default branch (defaults to true)
-    master: true
-    # enable for all branches in this repo (defaults to false)
     branches: true
-    # enable for pull requests coming from this repo (defaults to true)
-    pullRequests: true
-    # enable for pull requests coming from forks (defaults to false)
     pullRequestsFromForks: true
-    # add a "Review in Gitpod" button as a comment to pull requests (defaults to true)
-    addComment: true
-    # add a "Review in Gitpod" button to pull requests (defaults to false)
-    addBadge: false
-    # add a label once the prebuild is ready to pull requests (defaults to false)
     addLabel: prebuilt-in-gitpod
+vscode:
+  extensions:
+    - hbenl.vscode-test-explorer@2.15.0:koqDUMWDPJzELp/hdS/lWw==
+    - Swellaby.vscode-rust-test-adapter@0.11.0:Xg+YeZZQiVpVUsIkH+uiiw==
+    - serayuzgur.crates@0.4.7:HMkoguLcXp9M3ud7ac3eIw==
+    - belfz.search-crates-io@1.2.1:kSLnyrOhXtYPjQpKnMr4eQ==
+    - bungcip.better-toml@0.3.2:3QfgGxxYtGHfJKQU7H0nEw==
+    - webfreak.debug@0.24.0:1zVcRsAhewYEX3/A9xjMNw==

.theia/launch.json

@@ -0,0 +1,14 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+      {
+          "type": "gdb",
+          "request": "launch",
+          "name": "Debug Rust Code",
+          "preLaunchTask": "cargo",
+          "target": "${workspaceFolder}/target/debug/nu",
+          "cwd": "${workspaceFolder}",
+          "valuesFormatting": "parseText"
+      }
+  ]
+}

.theia/tasks.json

@@ -0,0 +1,12 @@
+{
+    "tasks": [
+        {
+            "command": "cargo",
+            "args": [
+                "build"
+            ],
+            "type": "process",
+            "label": "cargo",
+        }
+    ],
+}

CODE_OF_CONDUCT.md

@@ -55,7 +55,7 @@ a project may be further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at wycats@gmail.com. All
+reported by contacting the project team at wycats@gmail.com via email or by reaching out to @jturner, @gedge, or @andras_io on discord. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.
@@ -68,9 +68,9 @@ members of the project's leadership.
 ## Attribution
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+available at <https://www.contributor-covenant.org/version/1/4/code-of-conduct.html>
 
 [homepage]: https://www.contributor-covenant.org
 
 For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq
+<https://www.contributor-covenant.org/faq>

CONTRIBUTING.md

@@ -0,0 +1,75 @@
+# Contributing
+
+Welcome to nushell!
+
+*Note: for a more complete guide see [The nu contributor book](https://www.nushell.sh/contributor-book/)*
+
+For speedy contributions open it in Gitpod, nu will be pre-installed with the latest build in a VSCode like editor all from your browser.
+
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/nushell/nushell)
+
+To get live support from the community see our [Discord](https://discordapp.com/invite/NtAbbGn), [Twitter](https://twitter.com/nu_shell) or file an issue or feature request here on [GitHub](https://github.com/nushell/nushell/issues/new/choose)!
+<!--WIP-->
+
+## Developing
+
+### Set up
+
+This is no different than other Rust projects.
+
+```bash
+git clone https://github.com/nushell/nushell
+cd nushell
+cargo build
+```
+
+### Useful Commands
+
+- Build and run Nushell:
+
+  ```shell
+  cargo build --release && cargo run --release
+  ```
+
+- Build and run with extra features:
+  ```shell
+  cargo build --release --features=extra && cargo run --release --features=extra
+  ```
+
+- Run Clippy on Nushell:
+
+  ```shell
+  cargo clippy --all --features=stable
+  ```
+
+- Run all tests:
+
+  ```shell
+  cargo test --all --features=stable
+  ```
+
+- Run all tests for a specific command
+
+  ```shell
+  cargo test --package nu-cli --test main -- commands::<command_name_here>
+  ```
+
+- Check to see if there are code formatting issues
+
+  ```shell
+  cargo fmt --all -- --check
+  ```
+
+- Format the code in the project
+
+  ```shell
+  cargo fmt --all
+  ```
+
+### Debugging Tips
+
+- To view verbose logs when developing, enable the `trace` log level.
+
+  ```shell
+  cargo build --release --features=extra && cargo run --release --features=extra -- --loglevel trace
+  ```

Cargo.toml

@@ -1,179 +1,231 @@
 [package]
-name = "nu"
-version = "0.4.0"
-authors = ["Yehuda Katz <wycats@gmail.com>", "Jonathan Turner <jonathan.d.turner@gmail.com>", "Andrés N. Robalino <andres@androbtech.com>"]
-description = "A shell for the GitHub era"
-license = "MIT"
-edition = "2018"
-readme = "README.md"
+authors = ["The Nu Project Contributors"]
 default-run = "nu"
-repository = "https://github.com/nushell/nushell"
+description = "A new type of shell"
+documentation = "https://www.nushell.sh/book/"
+edition = "2018"
+exclude = ["images"]
 homepage = "https://www.nushell.sh"
-documentation = "https://book.nushell.sh"
+license = "MIT"
+name = "nu"
+readme = "README.md"
+repository = "https://github.com/nushell/nushell"
+version = "0.40.0"
+
+[workspace]
+members = ["crates/*/"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rustyline = "5.0.3"
-chrono = { version = "0.4.9", features = ["serde"] }
-derive-new = "0.5.8"
-prettytable-rs = "0.8.0"
-itertools = "0.8.0"
-ansi_term = "0.12.1"
-nom = "5.0.0"
-dunce = "1.0.0"
-indexmap = { version = "1.2.0", features = ["serde-1"] }
-chrono-humanize = "0.0.11"
-byte-unit = "3.0.1"
-base64 = "0.10.1"
-futures-preview = { version = "=0.3.0-alpha.18", features = ["compat", "io-compat"] }
-async-stream = "0.1.1"
-futures_codec = "0.2.5"
-num-traits = "0.2.8"
-term = "0.5.2"
-bytes = "0.4.12"
-log = "0.4.8"
-pretty_env_logger = "0.3.1"
-serde = { version = "1.0.100", features = ["derive"] }
-bson = { version = "0.14.0", features = ["decimal128"] }
-serde_json = "1.0.40"
-serde-hjson = "0.9.1"
-serde_yaml = "0.8"
-serde_bytes = "0.11.2"
-getset = "0.0.8"
-language-reporting = "0.4.0"
-app_dirs = "1.2.1"
-csv = "1.1"
-toml = "0.5.3"
-clap = "2.33.0"
-git2 = { version = "0.10.1", default_features = false }
-dirs = "2.0.2"
-glob = "0.3.0"
-ctrlc = "3.1.3"
-surf = "1.0.2"
-url = "2.1.0"
-roxmltree = "0.7.0"
-nom_locate = "1.0.0"
-nom-tracable = "0.4.0"
-unicode-xid = "0.2.0"
-serde_ini = "0.2.0"
-subprocess = "0.1.18"
-mime = "0.3.14"
-pretty-hex = "0.1.0"
-hex = "0.3.2"
-tempfile = "3.1.0"
-semver = "0.9.0"
-which = "2.0.1"
-textwrap = {version = "0.11.0", features = ["term_size"]}
-shellexpand = "1.0.0"
-futures-timer = "0.4.0"
-pin-utils = "0.1.0-alpha.4"
-num-bigint = { version = "0.2.3", features = ["serde"] }
-bigdecimal = { version = "0.1.0", features = ["serde"] }
-natural = "0.3.0"
-serde_urlencoded = "0.6.1"
-sublime_fuzzy = "0.5"
+nu-cli = { version = "0.40.0", path="./crates/nu-cli", default-features=false }
+nu-command = { version = "0.40.0", path="./crates/nu-command" }
+nu-completion = { version = "0.40.0", path="./crates/nu-completion" }
+nu-data = { version = "0.40.0", path="./crates/nu-data" }
+nu-engine = { version = "0.40.0", path="./crates/nu-engine" }
+nu-errors = { version = "0.40.0", path="./crates/nu-errors" }
+nu-parser = { version = "0.40.0", path="./crates/nu-parser" }
+nu-path = { version = "0.40.0", path="./crates/nu-path" }
+nu-plugin = { version = "0.40.0", path="./crates/nu-plugin" }
+nu-protocol = { version = "0.40.0", path="./crates/nu-protocol" }
+nu-source = { version = "0.40.0", path="./crates/nu-source" }
+nu-value-ext = { version = "0.40.0", path="./crates/nu-value-ext" }
 
-regex = {version = "1", optional = true }
-neso = { version = "0.5.0", optional = true }
-crossterm = { version = "0.10.2", optional = true }
-syntect = {version = "3.2.0", optional = true }
-onig_sys = {version = "=69.1.0", optional = true }
-heim = {version = "0.0.8", optional = true }
-battery = {version = "0.7.4", optional = true }
-rawkey = {version = "0.1.2", optional = true }
-clipboard = {version = "0.5", optional = true }
-ptree = {version = "0.2", optional = true }
-image = { version = "0.22.2", default_features = false, features = ["png_codec", "jpeg"], optional = true }
+nu_plugin_binaryview = { version = "0.40.0", path="./crates/nu_plugin_binaryview", optional=true }
+nu_plugin_chart = { version = "0.40.0", path="./crates/nu_plugin_chart", optional=true }
+nu_plugin_from_bson = { version = "0.40.0", path="./crates/nu_plugin_from_bson", optional=true }
+nu_plugin_from_sqlite = { version = "0.40.0", path="./crates/nu_plugin_from_sqlite", optional=true }
+nu_plugin_inc = { version = "0.40.0", path="./crates/nu_plugin_inc", optional=true }
+nu_plugin_match = { version = "0.40.0", path="./crates/nu_plugin_match", optional=true }
+nu_plugin_query_json = { version = "0.40.0", path="./crates/nu_plugin_query_json", optional=true }
+nu_plugin_s3 = { version = "0.40.0", path="./crates/nu_plugin_s3", optional=true }
+nu_plugin_selector = { version = "0.40.0", path="./crates/nu_plugin_selector", optional=true }
+nu_plugin_start = { version = "0.40.0", path="./crates/nu_plugin_start", optional=true }
+nu_plugin_textview = { version = "0.40.0", path="./crates/nu_plugin_textview", optional=true }
+nu_plugin_to_bson = { version = "0.40.0", path="./crates/nu_plugin_to_bson", optional=true }
+nu_plugin_to_sqlite = { version = "0.40.0", path="./crates/nu_plugin_to_sqlite", optional=true }
+nu_plugin_tree = { version = "0.40.0", path="./crates/nu_plugin_tree", optional=true }
+nu_plugin_xpath = { version = "0.40.0", path="./crates/nu_plugin_xpath", optional=true }
 
-[features]
-default = ["textview", "sys", "ps"]
-raw-key = ["rawkey", "neso"]
-textview = ["syntect", "onig_sys", "crossterm"]
-binaryview = ["image", "crossterm"]
-sys = ["heim", "battery"]
-ps = ["heim"]
-# trace = ["nom-tracable/trace"]
-all = ["raw-key", "textview", "binaryview", "sys", "ps", "clipboard", "ptree"]
-
-[dependencies.rusqlite]
-version = "0.20.0"
-features = ["bundled", "blob"]
+# Required to bootstrap the main binary
+ctrlc = { version="3.1.7", optional=true }
+futures = { version="0.3.12", features=["compat", "io-compat"] }
+itertools = "0.10.0"
 
 [dev-dependencies]
-pretty_assertions = "0.6.1"
+nu-test-support = { version = "0.40.0", path="./crates/nu-test-support" }
+serial_test = "0.5.1"
+hamcrest2 = "0.3.0"
+rstest = "0.10.0"
 
 [build-dependencies]
-toml = "0.5.3"
-serde = { version = "1.0.101", features = ["derive"] }
 
-[lib]
-name = "nu"
-path = "src/lib.rs"
+[features]
+fetch-support = ["nu-command/fetch", "nu-command/post"]
+sys-support = ["nu-command/sys", "nu-command/ps"]
+ctrlc-support = ["nu-cli/ctrlc", "nu-command/ctrlc"]
+rustyline-support = ["nu-cli/rustyline-support", "nu-command/rustyline-support"]
+term-support = ["nu-command/term"]
+uuid-support = ["nu-command/uuid_crate"]
+which-support = ["nu-command/which", "nu-engine/which"]
 
+default = [
+    "nu-cli/shadow-rs",
+    "sys-support",
+    "ctrlc-support",
+    "which-support",
+    "term-support",
+    "rustyline-support",
+    "match",
+    "fetch-support",
+    "zip-support",
+    "dataframe",
+]
+
+stable = ["default"]
+extra = [
+    "default",
+    "binaryview",
+    "inc",
+    "tree",
+    "textview",
+    "clipboard-cli",
+    "trash-support",
+    "uuid-support",
+    "start",
+    "bson",
+    "sqlite",
+    "s3",
+    "chart",
+    "xpath",
+    "selector",
+    "query-json",
+]
+
+wasi = ["inc", "match", "match", "tree", "rustyline-support"]
+
+# Stable (Default)
+inc = ["nu_plugin_inc"]
+match = ["nu_plugin_match"]
+textview = ["nu_plugin_textview"]
+
+# Extra
+binaryview = ["nu_plugin_binaryview"]
+bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
+chart = ["nu_plugin_chart"]
+clipboard-cli = ["nu-command/clipboard-cli"]
+query-json = ["nu_plugin_query_json"]
+s3 = ["nu_plugin_s3"]
+selector = ["nu_plugin_selector"]
+sqlite = ["nu_plugin_from_sqlite", "nu_plugin_to_sqlite"]
+start = ["nu_plugin_start"]
+trash-support = [
+    "nu-command/trash-support",
+    "nu-engine/trash-support",
+]
+tree = ["nu_plugin_tree"]
+xpath = ["nu_plugin_xpath"]
+zip-support = ["nu-command/zip"]
+
+#dataframe feature for nushell
+dataframe = [
+    "nu-engine/dataframe",
+    "nu-protocol/dataframe",
+    "nu-command/dataframe",
+    "nu-value-ext/dataframe",
+    "nu-data/dataframe",
+    "nu_plugin_to_bson/dataframe",
+]
+
+[profile.release]
+opt-level = "s"  # Optimize for size.
+
+# Core plugins that ship with `cargo install nu` by default
+# Currently, Cargo limits us to installing only one binary
+# unless we use [[bin]], so we use this as a workaround
 [[bin]]
-name = "nu_plugin_inc"
-path = "src/plugins/inc.rs"
-
-[[bin]]
-name = "nu_plugin_sum"
-path = "src/plugins/sum.rs"
-
-[[bin]]
-name = "nu_plugin_embed"
-path = "src/plugins/embed.rs"
-
-[[bin]]
-name = "nu_plugin_add"
-path = "src/plugins/add.rs"
-
-[[bin]]
-name = "nu_plugin_edit"
-path = "src/plugins/edit.rs"
-
-[[bin]]
-name = "nu_plugin_str"
-path = "src/plugins/str.rs"
-
-[[bin]]
-name = "nu_plugin_skip"
-path = "src/plugins/skip.rs"
-
-[[bin]]
-name = "nu_plugin_match"
-path = "src/plugins/match.rs"
-required-features = ["regex"]
-
-[[bin]]
-name = "nu_plugin_sys"
-path = "src/plugins/sys.rs"
-required-features = ["sys"]
-
-[[bin]]
-name = "nu_plugin_ps"
-path = "src/plugins/ps.rs"
-required-features = ["ps"]
-
-[[bin]]
-name = "nu_plugin_tree"
-path = "src/plugins/tree.rs"
-required-features = ["tree"]
-
-[[bin]]
-name = "nu_plugin_binaryview"
-path = "src/plugins/binaryview.rs"
-required-features = ["binaryview"]
-
-[[bin]]
-name = "nu_plugin_textview"
-path = "src/plugins/textview.rs"
+name = "nu_plugin_core_textview"
+path = "src/plugins/nu_plugin_core_textview.rs"
 required-features = ["textview"]
 
 [[bin]]
-name = "nu_plugin_docker"
-path = "src/plugins/docker.rs"
-required-features = ["docker"]
+name = "nu_plugin_core_inc"
+path = "src/plugins/nu_plugin_core_inc.rs"
+required-features = ["inc"]
 
+[[bin]]
+name = "nu_plugin_core_match"
+path = "src/plugins/nu_plugin_core_match.rs"
+required-features = ["match"]
+
+# Extra plugins
+
+[[bin]]
+name = "nu_plugin_extra_binaryview"
+path = "src/plugins/nu_plugin_extra_binaryview.rs"
+required-features = ["binaryview"]
+
+[[bin]]
+name = "nu_plugin_extra_tree"
+path = "src/plugins/nu_plugin_extra_tree.rs"
+required-features = ["tree"]
+
+[[bin]]
+name = "nu_plugin_extra_query_json"
+path = "src/plugins/nu_plugin_extra_query_json.rs"
+required-features = ["query-json"]
+
+[[bin]]
+name = "nu_plugin_extra_start"
+path = "src/plugins/nu_plugin_extra_start.rs"
+required-features = ["start"]
+
+[[bin]]
+name = "nu_plugin_extra_s3"
+path = "src/plugins/nu_plugin_extra_s3.rs"
+required-features = ["s3"]
+
+[[bin]]
+name = "nu_plugin_extra_chart_bar"
+path = "src/plugins/nu_plugin_extra_chart_bar.rs"
+required-features = ["chart"]
+
+[[bin]]
+name = "nu_plugin_extra_chart_line"
+path = "src/plugins/nu_plugin_extra_chart_line.rs"
+required-features = ["chart"]
+
+[[bin]]
+name = "nu_plugin_extra_xpath"
+path = "src/plugins/nu_plugin_extra_xpath.rs"
+required-features = ["xpath"]
+
+[[bin]]
+name = "nu_plugin_extra_selector"
+path = "src/plugins/nu_plugin_extra_selector.rs"
+required-features = ["selector"]
+
+[[bin]]
+name = "nu_plugin_extra_from_bson"
+path = "src/plugins/nu_plugin_extra_from_bson.rs"
+required-features = ["bson"]
+
+[[bin]]
+name = "nu_plugin_extra_to_bson"
+path = "src/plugins/nu_plugin_extra_to_bson.rs"
+required-features = ["bson"]
+
+[[bin]]
+name = "nu_plugin_extra_from_sqlite"
+path = "src/plugins/nu_plugin_extra_from_sqlite.rs"
+required-features = ["sqlite"]
+
+[[bin]]
+name = "nu_plugin_extra_to_sqlite"
+path = "src/plugins/nu_plugin_extra_to_sqlite.rs"
+required-features = ["sqlite"]
+
+# Main nu binary
 [[bin]]
 name = "nu"
 path = "src/main.rs"

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Yehuda Katz, Jonathan Turner
+Copyright (c) 2019 - 2021 Nushell Project
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile.toml

@@ -4,21 +4,12 @@ command = "lalrpop"
 args = ["src/parser/parser.lalrpop"]
 
 [tasks.baseline]
-dependencies = ["lalrpop"]
-
-[tasks.build]
 command = "cargo"
-args = ["build"]
-dependencies = ["lalrpop"]
+args = ["build", "--bins"]
 
 [tasks.run]
 command = "cargo"
-args = ["run", "--release"]
-dependencies = ["baseline"]
-
-[tasks.release]
-command = "cargo"
-args = ["build", "--release"]
+args = ["run"]
 dependencies = ["baseline"]
 
 [tasks.test]

README.build.txt

@@ -0,0 +1 @@
+Nu will look for the plugins in your PATH on startup. While nu will have some functionality without them, for full functionality you'll need to copy them into your path so they can be loaded.

README.md

@@ -1,314 +1,288 @@
+# README
+
 [![Crates.io](https://img.shields.io/crates/v/nu.svg)](https://crates.io/crates/nu)
-[![Build Status](https://dev.azure.com/nushell/nushell/_apis/build/status/nushell.nushell?branchName=master)](https://dev.azure.com/nushell/nushell/_build/latest?definitionId=2&branchName=master)
+[![Build Status](https://dev.azure.com/nushell/nushell/_apis/build/status/nushell.nushell?branchName=main)](https://dev.azure.com/nushell/nushell/_build/latest?definitionId=2&branchName=main)
 [![Discord](https://img.shields.io/discord/601130461678272522.svg?logo=discord)](https://discord.gg/NtAbbGn)
 [![The Changelog #363](https://img.shields.io/badge/The%20Changelog-%23363-61c192.svg)](https://changelog.com/podcast/363)
+[![@nu_shell](https://img.shields.io/badge/twitter-@nu_shell-1DA1F3?style=flat-square)](https://twitter.com/nu_shell)
+![GitHub commit activity](https://img.shields.io/github/commit-activity/m/nushell/nushell)
+![GitHub contributors](https://img.shields.io/github/contributors/nushell/nushell)
 
+## Nushell
 
-# Nu Shell
+A new type of shell.
 
-A modern shell for the GitHub era.
+![Example of nushell](images/nushell-autocomplete5.gif "Example of nushell")
 
-![Example of nushell](images/nushell-autocomplete.gif "Example of nushell")
+## Status
 
-# Status
+This project has reached a minimum-viable product level of quality.
+While contributors dogfood it as their daily driver, it may be unstable for some commands.
+Future releases will work to fill out missing features and improve stability.
+Its design is also subject to change as it matures.
 
-This project has reached a minimum-viable product level of quality. While contributors dogfood it as their daily driver, it may be unstable for some commands. Future releases will work to fill out missing features and improve stability. Its design is also subject to change as it matures.
+Nu comes with a set of built-in commands (listed below).
+If a command is unknown, the command will shell-out and execute it (using cmd on Windows or bash on Linux and macOS), correctly passing through stdin, stdout, and stderr, so things like your daily git workflows and even `vim` will work just fine.
 
-Nu comes with a set of built-in commands (listed below). If a command is unknown, the command will shell-out and execute it (using cmd on Windows or bash on Linux and macOS), correctly passing through stdin, stdout, and stderr, so things like your daily git workflows and even `vim` will work just fine.
+## Learning more
 
-# Learning more
+There are a few good resources to learn about Nu.
+There is a [book](https://www.nushell.sh/book/) about Nu that is currently in progress.
+The book focuses on using Nu and its core concepts.
 
-There are a few good resources to learn about Nu. There is a [book](https://book.nushell.sh) about Nu that is currently in progress. The book focuses on using Nu and its core concepts.
-
-If you're a developer who would like to contribute to Nu, we're also working on a [book for developers](https://github.com/nushell/contributor-book/tree/master/en) to help you get started. There are also [good first issues](https://github.com/nushell/nushell/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22) to help you dive in.
+If you're a developer who would like to contribute to Nu, we're also working on a [book for developers](https://www.nushell.sh/contributor-book/) to help you get started.
+There are also [good first issues](https://github.com/nushell/nushell/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22) to help you dive in.
 
 We also have an active [Discord](https://discord.gg/NtAbbGn) and [Twitter](https://twitter.com/nu_shell) if you'd like to come and chat with us.
 
+You can also find information on more specific topics in our [cookbook](https://www.nushell.sh/cookbook/).
+
 Try it in Gitpod.
 
 [![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/nushell/nushell)
 
-# Installation
+## Installation
 
-## Local
+### Local
 
-Up-to-date installation instructions can be found in the [installation chapter of the book](https://book.nushell.sh/en/installation).
+Up-to-date installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/installation.html). **Windows users**: please note that Nu works on Windows 10 and does not currently have Windows 7/8.1 support.
 
-To build Nu, you will need to use the **nightly** version of the compiler.
+To build Nu, you will need to use the **latest stable (1.51 or later)** version of the compiler.
 
 Required dependencies:
 
-* pkg-config and libssl (only needed on Linux)
-  * on Debian/Ubuntu: `apt install pkg-config libssl-dev`
+-   pkg-config and libssl (only needed on Linux)
+    -   On Debian/Ubuntu: `apt install pkg-config libssl-dev`
 
 Optional dependencies:
 
-* To use Nu with all possible optional features enabled, you'll also need the following:
-  * on Linux (on Debian/Ubuntu): `apt install libxcb-composite0-dev libx11-dev`
+-   To use Nu with all possible optional features enabled, you'll also need the following:
+    -   On Linux (on Debian/Ubuntu): `apt install libxcb-composite0-dev libx11-dev`
 
-To install Nu via cargo (make sure you have installed [rustup](https://rustup.rs/) and the beta compiler via `rustup install beta`):
+To install Nu via cargo (make sure you have installed [rustup](https://rustup.rs/) and the latest stable compiler via `rustup install stable`):
 
-```
-cargo +beta install nu
+```shell
+cargo install nu
 ```
 
-You can also install Nu with all the bells and whistles (be sure to have installed the [dependencies](https://book.nushell.sh/en/installation#dependencies) for your platform):
+To install Nu via the [Windows Package Manager](https://aka.ms/winget-cli):
 
-```
-cargo +beta install nu --all-features
+```shell
+winget install nushell
 ```
 
-## Docker
+You can also build Nu yourself with all the bells and whistles (be sure to have installed the [dependencies](https://www.nushell.sh/book/installation.html#dependencies) for your platform), once you have checked out this repo with git:
 
-If you want to pull a pre-built container, you can browse tags for the [nushell organization](https://quay.io/organization/nushell)
-on Quay.io. Pulling a container would come down to:
-
-```bash
-$ docker pull quay.io/nushell/nu
-$ docker pull quay.io/nushell/nu-base
+```shell
+cargo build --workspace --features=extra
 ```
-
-Both "nu-base" and "nu" provide the nu binary, however nu-base also includes the source code at `/code`
-in the container and all dependencies.
-
-Optionally, you can also build the containers locally using the [dockerfiles provided](docker):
-To build the base image:
-
-```bash
-$ docker build -f docker/Dockerfile.nu-base -t nushell/nu-base .
-```
-
-And then to build the smaller container (using a Multistage build):
-
-```bash
-$ docker build -f docker/Dockerfile -t nushell/nu .
-```
-
-Either way, you can run either container as follows:
-
-```bash
-$ docker run -it nushell/nu-base
-$ docker run -it nushell/nu
-/> exit
-```
-
-The second container is a bit smaller if the size is important to you.
-
-## Packaging status
+### Packaging status
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/nushell.svg)](https://repology.org/project/nushell/versions)
 
-### Fedora
+#### Fedora
 
 [COPR repo](https://copr.fedorainfracloud.org/coprs/atim/nushell/): `sudo dnf copr enable atim/nushell -y && sudo dnf install nushell -y`
 
-# Philosophy
+## Philosophy
 
-Nu draws inspiration from projects like PowerShell, functional programming languages, and modern CLI tools. Rather than thinking of files and services as raw streams of text, Nu looks at each input as something with structure. For example, when you list the contents of a directory, what you get back is a table of rows, where each row represents an item in that directory. These values can be piped through a series of steps, in a series of commands called a 'pipeline'.
+Nu draws inspiration from projects like PowerShell, functional programming languages, and modern CLI tools.
+Rather than thinking of files and services as raw streams of text, Nu looks at each input as something with structure.
+For example, when you list the contents of a directory, what you get back is a table of rows, where each row represents an item in that directory.
+These values can be piped through a series of steps, in a series of commands called a 'pipeline'.
 
-## Pipelines
+### Pipelines
 
-In Unix, it's common to pipe between commands to split up a sophisticated command over multiple steps. Nu takes this a step further and builds heavily on the idea of _pipelines_. Just as the Unix philosophy, Nu allows commands to output from stdout and read from stdin. Additionally, commands can output structured data (you can think of this as a third kind of stream). Commands that work in the pipeline fit into one of three categories:
+In Unix, it's common to pipe between commands to split up a sophisticated command over multiple steps.
+Nu takes this a step further and builds heavily on the idea of _pipelines_.
+Just as the Unix philosophy, Nu allows commands to output to stdout and read from stdin.
+Additionally, commands can output structured data (you can think of this as a third kind of stream).
+Commands that work in the pipeline fit into one of three categories:
 
-* Commands that produce a stream (eg, `ls`)
-* Commands that filter a stream (eg, `where type == "Directory"`)
-* Commands that consume the output of the pipeline (eg, `autoview`)
+-   Commands that produce a stream (e.g., `ls`)
+-   Commands that filter a stream (eg, `where type == "Dir"`)
+-   Commands that consume the output of the pipeline (e.g., `autoview`)
 
 Commands are separated by the pipe symbol (`|`) to denote a pipeline flowing left to right.
 
-```
-/home/jonathan/Source/nushell(master)> ls | where type == "Directory" | autoview
-━━━━┯━━━━━━━━━━━┯━━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━┯━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━
- #  │ name      │ type      │ readonly │ size   │ accessed     │ modified
-────┼───────────┼───────────┼──────────┼────────┼──────────────┼────────────────
-  0 │ .azure    │ Directory │          │ 4.1 KB │ 2 months ago │ a day ago
-  1 │ target    │ Directory │          │ 4.1 KB │ 3 days ago   │ 3 days ago
-  2 │ images    │ Directory │          │ 4.1 KB │ 2 months ago │ 2 weeks ago
-  3 │ tests     │ Directory │          │ 4.1 KB │ 2 months ago │ 37 minutes ago
-  4 │ tmp       │ Directory │          │ 4.1 KB │ 2 weeks ago  │ 2 weeks ago
-  5 │ src       │ Directory │          │ 4.1 KB │ 2 months ago │ 37 minutes ago
-  6 │ assets    │ Directory │          │ 4.1 KB │ a month ago  │ a month ago
-  7 │ docs      │ Directory │          │ 4.1 KB │ 2 months ago │ 2 months ago
-━━━━┷━━━━━━━━━━━┷━━━━━━━━━━━┷━━━━━━━━━━┷━━━━━━━━┷━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━
+```shell
+> ls | where type == "Dir" | autoview
+───┬────────┬──────┬───────┬──────────────
+ # │ name   │ type │ size  │ modified
+───┼────────┼──────┼───────┼──────────────
+ 0 │ assets │ Dir  │ 128 B │ 5 months ago
+ 1 │ crates │ Dir  │ 704 B │ 50 mins ago
+ 2 │ debian │ Dir  │ 352 B │ 5 months ago
+ 3 │ docker │ Dir  │ 288 B │ 3 months ago
+ 4 │ docs   │ Dir  │ 192 B │ 50 mins ago
+ 5 │ images │ Dir  │ 160 B │ 5 months ago
+ 6 │ src    │ Dir  │ 128 B │ 1 day ago
+ 7 │ target │ Dir  │ 160 B │ 5 days ago
+ 8 │ tests  │ Dir  │ 192 B │ 3 months ago
+───┴────────┴──────┴───────┴──────────────
 ```
 
-Because most of the time you'll want to see the output of a pipeline, `autoview` is assumed. We could have also written the above:
+Because most of the time you'll want to see the output of a pipeline, `autoview` is assumed.
+We could have also written the above:
 
-```
-/home/jonathan/Source/nushell(master)> ls | where type == Directory
+```shell
+> ls | where type == Dir
 ```
 
-Being able to use the same commands and compose them differently is an important philosophy in Nu. For example, we could use the built-in `ps` command as well to get a list of the running processes, using the same `where` as above.
-
-```text
-/home/jonathan/Source/nushell(master)> ps | where cpu > 0
-━━━┯━━━━━━━┯━━━━━━━━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━━━
- # │ pid   │ name            │ status   │ cpu
-───┼───────┼─────────────────┼──────────┼──────────
- 0 │   992 │ chrome          │ Sleeping │ 6.988768
- 1 │  4240 │ chrome          │ Sleeping │ 5.645982
- 2 │ 13973 │ qemu-system-x86 │ Sleeping │ 4.996551
- 3 │ 15746 │ nu              │ Sleeping │ 84.59905
-━━━┷━━━━━━━┷━━━━━━━━━━━━━━━━━┷━━━━━━━━━━┷━━━━━━━━━━
+Being able to use the same commands and compose them differently is an important philosophy in Nu.
+For example, we could use the built-in `ps` command to get a list of the running processes, using the same `where` as above.
 
+```shell
+> ps | where cpu > 0
+───┬────────┬───────────────────┬──────────┬─────────┬──────────┬──────────
+ # │ pid    │ name              │ status   │ cpu     │ mem      │ virtual
+───┼────────┼───────────────────┼──────────┼─────────┼──────────┼──────────
+ 0 │    435 │ irq/142-SYNA327   │ Sleeping │  7.5699 │      0 B │      0 B
+ 1 │   1609 │ pulseaudio        │ Sleeping │  6.5605 │  10.6 MB │   2.3 GB
+ 2 │   1625 │ gnome-shell       │ Sleeping │  6.5684 │ 639.6 MB │   7.3 GB
+ 3 │   2202 │ Web Content       │ Sleeping │  6.8157 │ 320.8 MB │   3.0 GB
+ 4 │ 328788 │ nu_plugin_core_ps │ Sleeping │ 92.5750 │   5.9 MB │ 633.2 MB
+───┴────────┴───────────────────┴──────────┴─────────┴──────────┴──────────
 ```
 
-## Opening files
+### Opening files
 
-Nu can load file and URL contents as raw text or as structured data (if it recognizes the format). For example, you can load a .toml file as structured data and explore it:
+Nu can load file and URL contents as raw text or structured data (if it recognizes the format).
+For example, you can load a .toml file as structured data and explore it:
 
-```
-/home/jonathan/Source/nushell(master)> open Cargo.toml
-━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━
- bin              │ dependencies   │ dev-dependencies
-──────────────────┼────────────────┼──────────────────
- [table: 12 rows] │ [table: 1 row] │ [table: 1 row]
-━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━
+```shell
+> open Cargo.toml
+────────────────────┬───────────────────────────
+ bin                │ [table 18 rows]
+ build-dependencies │ [row serde toml]
+ dependencies       │ [row 29 columns]
+ dev-dependencies   │ [row nu-test-support]
+ features           │ [row 19 columns]
+ package            │ [row 12 columns]
+ workspace          │ [row members]
+────────────────────┴───────────────────────────
 ```
 
 We can pipeline this into a command that gets the contents of one of the columns:
 
-```
-/home/jonathan/Source/nushell(master)> open Cargo.toml | get package
-━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━┯━━━━━━━━━┯━━━━━━┯━━━━━━━━━
- authors         │ description                │ edition │ license │ name │ version
-─────────────────┼────────────────────────────┼─────────┼─────────┼──────┼─────────
- [table: 3 rows] │ A shell for the GitHub era │ 2018    │ MIT     │ nu   │ 0.4.0
-━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━┷━━━━━━━━━┷━━━━━━┷━━━━━━━━━
+```shell
+> open Cargo.toml | get package
+───────────────┬────────────────────────────────────
+ authors       │ [table 1 rows]
+ default-run   │ nu
+ description   │ A new type of shell
+ documentation │ https://www.nushell.sh/book/
+ edition       │ 2018
+ exclude       │ [table 1 rows]
+ homepage      │ https://www.nushell.sh
+ license       │ MIT
+ name          │ nu
+ readme        │ README.md
+ repository    │ https://github.com/nushell/nushell
+ version       │ 0.32.0
+───────────────┴────────────────────────────────────
 ```
 
 Finally, we can use commands outside of Nu once we have the data we want:
 
-```
-/home/jonathan/Source/nushell(master)> open Cargo.toml | get package.version | echo $it
-0.4.0
+```shell
+> open Cargo.toml | get package.version
+0.32.0
 ```
 
-Here we use the variable `$it` to refer to the value being piped to the external command.
+### Configuration
 
-## Shells
+Nu has early support for configuring the shell. You can refer to the book for a list of [all supported variables](https://www.nushell.sh/book/configuration.html).
 
-Nu will work inside of a single directory and allow you to navigate around your filesystem by default. Nu also offers a way of adding additional working directories that you can jump between, allowing you to work in multiple directories at the same time.
+To set one of these variables, you can use `config set`. For example:
 
-To do so, use the `enter` command, which will allow you create a new "shell" and enter it at the specified path. You can toggle between this new shell and the original shell with the `p` (for previous) and `n` (for next), allowing you to navigate around a ring buffer of shells. Once you're done with a shell, you can `exit` it and remove it from the ring buffer.
+```shell
+> config set line_editor.edit_mode "vi"
+> config set path $nu.path
+```
+
+### Shells
+
+Nu will work inside of a single directory and allow you to navigate around your filesystem by default.
+Nu also offers a way of adding additional working directories that you can jump between, allowing you to work in multiple directories simultaneously.
+
+To do so, use the `enter` command, which will allow you to create a new "shell" and enter it at the specified path.
+You can toggle between this new shell and the original shell with the `p` (for previous) and `n` (for next), allowing you to navigate around a ring buffer of shells.
+Once you're done with a shell, you can `exit` it and remove it from the ring buffer.
 
 Finally, to get a list of all the current shells, you can use the `shells` command.
 
-## Plugins
+### Plugins
 
-Nu supports plugins that offer additional functionality to the shell and follow the same structured data model that built-in commands use. This allows you to extend nu for your needs.
+Nu supports plugins that offer additional functionality to the shell and follow the same structured data model that built-in commands use.
+This allows you to extend nu for your needs.
 
 There are a few examples in the `plugins` directory.
 
-Plugins are binaries that are available in your path and follow a `nu_plugin_*` naming convention. These binaries interact with nu via a simple JSON-RPC protocol where the command identifies itself and passes along its configuration, which then makes it available for use. If the plugin is a filter, data streams to it one element at a time, and it can stream data back in return via stdin/stdout. If the plugin is a sink, it is given the full vector of final data and is given free reign over stdin/stdout to use as it pleases.
+Plugins are binaries that are available in your path and follow a `nu_plugin_*` naming convention.
+These binaries interact with nu via a simple JSON-RPC protocol where the command identifies itself and passes along its configuration, making it available for use.
+If the plugin is a filter, data streams to it one element at a time, and it can stream data back in return via stdin/stdout.
+If the plugin is a sink, it is given the full vector of final data and is given free reign over stdin/stdout to use as it pleases.
 
-# Goals
+## Goals
 
 Nu adheres closely to a set of goals that make up its design philosophy. As features are added, they are checked against these goals.
 
-* First and foremost, Nu is cross-platform. Commands and techniques should carry between platforms and offer first-class consistent support for Windows, macOS, and Linux.
+-   First and foremost, Nu is cross-platform. Commands and techniques should carry between platforms and offer consistent first-class support for Windows, macOS, and Linux.
 
-* Nu ensures direct compatibility with existing platform-specific executables that make up people's workflows.
+-   Nu ensures direct compatibility with existing platform-specific executables that make up people's workflows.
 
-* Nu's workflow and tools should have the usability in day-to-day experience of using a shell in 2019 (and beyond).
+-   Nu's workflow and tools should have the usability in day-to-day experience of using a shell in 2019 (and beyond).
 
-* Nu views data as both structured and unstructured. It is a structured shell like PowerShell.
+-   Nu views data as both structured and unstructured. It is a structured shell like PowerShell.
 
-* Finally, Nu views data functionally. Rather than using mutation, pipelines act as a means to load, change, and save data without mutable state.
+-   Finally, Nu views data functionally. Rather than using mutation, pipelines act as a means to load, change, and save data without mutable state.
 
-# Commands
-## Initial commands
-| command | description |
-| ------------- | ------------- |
-| cd path | Change to a new path |
-| cp source path | Copy files |
-| date (--utc) | Get the current datetime |
-| fetch url | Fetch contents from a url and retrieve data as a table if possible |
-| help | Display help information about commands |
-| ls (path) | View the contents of the current or given path |
-| mkdir path | Make directories, creates intermediary directories as required. |
-| mv source target | Move files or directories. |
-| open filename | Load a file into a cell, convert to table if possible (avoid by appending '--raw') |
-| post url body (--user <user>) (--password <password>) | Post content to a url and retrieve data as a table if possible |
-| ps | View current processes |
-| sys | View information about the current system |
-| which filename | Finds a program file. |
-| rm   {file or directory} | Remove a file, (for removing directory append '--recursive') |
-| version | Display Nu version |
+## Commands
 
-## Shell commands
-| command | description |
-| ------- | ----------- |
-| exit (--now) | Exit the current shell (or all shells) |
-| enter (path) | Create a new shell and begin at this path |
-| p | Go to previous shell |
-| n | Go to next shell |
-| shells | Display the list of current shells |
+You can find a list of Nu commands, complete with documentation, in [quick command references](https://www.nushell.sh/book/command_reference.html).
 
-## Filters on tables (structured data)
-| command | description |
-| ------------- | ------------- |
-| add column-or-column-path value | Add a new column to the table |
-| edit column-or-column-path value | Edit an existing column to have a new value |
-| embed column | Creates a new table of one column with the given name, and places the current table inside of it |
-| first amount | Show only the first number of rows |
-| get column-or-column-path | Open column and get data from the corresponding cells |
-| inc (column-or-column-path) | Increment a value or version. Optionally use the column of a table |
-| last amount | Show only the last number of rows |
-| nth row-number | Return only the selected row |
-| pick ...columns | Down-select table to only these columns |
-| pivot --header-row <headers> | Pivot the tables, making columns into rows and vice versa |
-| reject ...columns | Remove the given columns from the table |
-| reverse | Reverses the table. |
-| skip amount | Skip a number of rows |
-| skip-while condition | Skips rows while the condition matches. |
-| sort-by ...columns | Sort by the given columns |
-| str (column) | Apply string function. Optionally use the column of a table |
-| sum | Sum a column of values |
-| tags | Read the tags (metadata) for values |
-| to-bson | Convert table into .bson binary data |
-| to-csv | Convert table into .csv text |
-| to-json | Convert table into .json text |
-| to-sqlite | Convert table to sqlite .db binary data |
-| to-toml | Convert table into .toml text |
-| to-tsv | Convert table into .tsv text |
-| to-url | Convert table to a urlencoded string |
-| to-yaml | Convert table into .yaml text |
-| where condition | Filter table to match the condition |
+## Progress
 
-## Filters on text (unstructured data)
-| command | description |
-| ------------- | ------------- |
-| from-bson | Parse binary data as .bson and create table |
-| from-csv | Parse text as .csv and create table |
-| from-ini | Parse text as .ini and create table |
-| from-json | Parse text as .json and create table |
-| from-sqlite | Parse binary data as sqlite .db and create table |
-| from-ssv --minimum-spaces <minimum number of spaces to count as a separator> | Parse text as space-separated values and create table |
-| from-toml | Parse text as .toml and create table |
-| from-tsv  | Parse text as .tsv and create table  |
-| from-url | Parse urlencoded string and create a table |
-| from-xml | Parse text as .xml and create a table |
-| from-yaml | Parse text as a .yaml/.yml and create a table |
-| lines | Split single string into rows, one per line |
-| size | Gather word count statistics on the text |
-| split-column sep ...column-names | Split row contents across multiple columns via the separator, optionally give the columns names |
-| split-row sep | Split row contents over multiple rows via the separator |
-| trim | Trim leading and following whitespace from text data |
-| {external-command} $it | Run external command with given arguments, replacing $it with each row text |
+Nu is in heavy development and will naturally change as it matures and people use it. The chart below isn't meant to be exhaustive, but rather helps give an idea for some of the areas of development and their relative completion:
 
-## Consuming commands
-| command | description |
-| ------------- | ------------- |
-| autoview | View the contents of the pipeline as a table or list |
-| binaryview | Autoview of binary data (optional feature) |
-| clip | Copy the contents of the pipeline to the copy/paste buffer (optional feature) |
-| save filename | Save the contents of the pipeline to a file |
-| table | View the contents of the pipeline as a table |
-| textview | Autoview of text data |
-| tree | View the contents of the pipeline as a tree (optional feature) |
+| Features      | Not started | Prototype | MVP | Preview | Mature | Notes                                                                |
+| ------------- | :---------: | :-------: | :-: | :-----: | :----: | -------------------------------------------------------------------- |
+| Aliases       |             |           |  X  |         |        | Aliases allow for shortening large commands, while passing flags     |
+| Notebook      |             |     X     |     |         |        | Initial jupyter support, but it loses state and lacks features       |
+| File ops      |             |           |  X  |         |        | cp, mv, rm, mkdir have some support, but lacking others              |
+| Environment   |             |           |  X  |         |        | Temporary environment and scoped environment variables               |
+| Shells        |             |     X     |     |         |        | Basic value and file shells, but no opt-in/opt-out for commands      |
+| Protocol      |             |           |  X  |         |        | Streaming protocol is serviceable                                    |
+| Plugins       |             |     X     |     |         |        | Plugins work on one row at a time, lack batching and expression eval |
+| Errors        |             |           |  X  |         |        | Error reporting works, but could use usability polish                |
+| Documentation |             |           |  X  |         |        | Book updated to latest release, including usage examples             |
+| Paging        |             |     X     |     |         |        | Textview has paging, but we'd like paging for tables                 |
+| Functions     |             |           |  X  |         |        | Functions and aliases are supported                                  |
+| Variables     |             |           |  X  |         |        | Nu supports variables and environment variables                      |
+| Completions   |             |           |  X  |         |        | Completions for filepaths                                            |
+| Type-checking |             |           |  X  |         |        | Commands check basic types, but input/output isn't checked           |
 
-# License
+## Officially Supported By
 
-The project is made available under the MIT license. See "LICENSE" for more information.
+Please submit an issue or PR to be added to this list.
 
+###   Integrations
+-   [zoxide](https://github.com/ajeetdsouza/zoxide)
+-   [starship](https://github.com/starship/starship)
+###   Mentions
+-   [The Python Launcher for Unix](https://github.com/brettcannon/python-launcher#how-do-i-get-a-table-of-python-executables-in-nushell)
+
+## Contributing
+
+See [Contributing](CONTRIBUTING.md) for details.
+
+Thanks to all the people who already contributed!
+
+<a href="https://github.com/nushell/nushell/graphs/contributors">
+  <img src="https://contributors-img.web.app/image?repo=nushell/nushell" />
+</a>
+
+## License
+
+The project is made available under the MIT license. See the `LICENSE` file for more information.

build.rs

@@ -1,39 +0,0 @@
-use serde::Deserialize;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::env;
-use std::path::Path;
-
-#[derive(Deserialize)]
-struct Feature {
-    #[allow(unused)]
-    description: String,
-    enabled: bool,
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let input = env::var("CARGO_MANIFEST_DIR").unwrap();
-    let all_on = env::var("NUSHELL_ENABLE_ALL_FLAGS").is_ok();
-    let flags: HashSet<String> = env::var("NUSHELL_ENABLE_FLAGS")
-        .map(|s| s.split(",").map(|s| s.to_string()).collect())
-        .unwrap_or_else(|_| HashSet::new());
-
-    if all_on && !flags.is_empty() {
-        println!(
-            "cargo:warning={}",
-            "Both NUSHELL_ENABLE_ALL_FLAGS and NUSHELL_ENABLE_FLAGS were set. You don't need both."
-        );
-    }
-
-    let path = Path::new(&input).join("features.toml");
-
-    let toml: HashMap<String, Feature> = toml::from_str(&std::fs::read_to_string(path)?)?;
-
-    for (key, value) in toml.iter() {
-        if value.enabled == true || all_on || flags.contains(key) {
-            println!("cargo:rustc-cfg={}", key);
-        }
-    }
-
-    Ok(())
-}

crates/README.md

@@ -0,0 +1,13 @@
+# Nushell core libraries and plugins
+
+These sub-crates form both the foundation for Nu and a set of plugins which extend Nu with additional functionality.
+
+Foundational libraries are split into two kinds of crates:
+
+* Core crates - those crates that work together to build the Nushell language engine
+* Support crates - a set of crates that support the engine with additional features like JSON support, ANSI support, and more.
+
+Plugins are likewise also split into two types:
+
+* Core plugins - plugins that provide part of the default experience of Nu, including access to the system properties, processes, and web-connectivity features.
+* Extra plugins - these plugins run a wide range of differnt capabilities like working with different file types, charting, viewing binary data, and more.

crates/nu-ansi-term/.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

crates/nu-ansi-term/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+authors = [
+    "ogham@bsago.me",
+    "Ryan Scheel (Havvy) <ryan.havvy@gmail.com>",
+    "Josh Triplett <josh@joshtriplett.org>",
+    "The Nu Project Contributors",
+]
+description = "Library for ANSI terminal colors and styles (bold, underline)"
+edition = "2018"
+license = "MIT"
+name = "nu-ansi-term"
+version = "0.40.0"
+
+[lib]
+doctest = false
+# name = "nu-ansi-term"
+
+[features]
+derive_serde_style = ["serde"]
+
+[dependencies]
+overload = "0.1.1"
+serde = { version="1.0.90", features=["derive"], optional=true }
+
+# [dependencies.serde]
+# version = "1.0.90"
+# features = ["derive"]
+# optional = true
+
+[target.'cfg(target_os="windows")'.dependencies.winapi]
+version = "0.3.4"
+features = ["consoleapi", "errhandlingapi", "fileapi", "handleapi", "processenv"]
+
+[dev-dependencies]
+doc-comment = "0.3"
+regex = "1.1.9"
+
+[dev-dependencies.serde_json]
+version = "1.0.39"

crates/nu-ansi-term/LICENCE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Benjamin Sago
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

crates/nu-ansi-term/README.md

@@ -0,0 +1,182 @@
+# nu-ansi-term
+
+> This is a copy of rust-ansi-term but with Color change to Color and light foreground colors added (90-97) as well as light background colors added (100-107).
+
+This is a library for controlling colors and formatting, such as red bold text or blue underlined text, on ANSI terminals.
+
+### [View the Rustdoc](https://docs.rs/nu_ansi_term/)
+
+# Installation
+
+This crate works with [Cargo](http://crates.io). Add the following to your `Cargo.toml` dependencies section:
+
+```toml
+[dependencies]
+nu_ansi_term = "0.13"
+```
+
+## Basic usage
+
+There are three main types in this crate that you need to be concerned with: `ANSIString`, `Style`, and `Color`.
+
+A `Style` holds stylistic information: foreground and background colors, whether the text should be bold, or blinking, or other properties.
+The `Color` enum represents the available colors.
+And an `ANSIString` is a string paired with a `Style`.
+
+`Color` is also available as an alias to `Color`.
+
+To format a string, call the `paint` method on a `Style` or a `Color`, passing in the string you want to format as the argument.
+For example, here’s how to get some red text:
+
+```rust
+use nu_ansi_term::Color::Red;
+
+println!("This is in red: {}", Red.paint("a red string"));
+```
+
+It’s important to note that the `paint` method does _not_ actually return a string with the ANSI control characters surrounding it.
+Instead, it returns an `ANSIString` value that has a `Display` implementation that, when formatted, returns the characters.
+This allows strings to be printed with a minimum of `String` allocations being performed behind the scenes.
+
+If you _do_ want to get at the escape codes, then you can convert the `ANSIString` to a string as you would any other `Display` value:
+
+```rust
+use nu_ansi_term::Color::Red;
+
+let red_string = Red.paint("a red string").to_string();
+```
+
+**Note for Windows 10 users:** On Windows 10, the application must enable ANSI support first:
+
+```rust,ignore
+let enabled = nu_ansi_term::enable_ansi_support();
+```
+
+## Bold, underline, background, and other styles
+
+For anything more complex than plain foreground color changes, you need to construct `Style` values themselves, rather than beginning with a `Color`.
+You can do this by chaining methods based on a new `Style`, created with `Style::new()`.
+Each method creates a new style that has that specific property set.
+For example:
+
+```rust
+use nu_ansi_term::Style;
+
+println!("How about some {} and {}?",
+         Style::new().bold().paint("bold"),
+         Style::new().underline().paint("underline"));
+```
+
+For brevity, these methods have also been implemented for `Color` values, so you can give your styles a foreground color without having to begin with an empty `Style` value:
+
+```rust
+use nu_ansi_term::Color::{Blue, Yellow};
+
+println!("Demonstrating {} and {}!",
+         Blue.bold().paint("blue bold"),
+         Yellow.underline().paint("yellow underline"));
+
+println!("Yellow on blue: {}", Yellow.on(Blue).paint("wow!"));
+```
+
+The complete list of styles you can use are:
+`bold`, `dimmed`, `italic`, `underline`, `blink`, `reverse`, `hidden`, and `on` for background colors.
+
+In some cases, you may find it easier to change the foreground on an existing `Style` rather than starting from the appropriate `Color`.
+You can do this using the `fg` method:
+
+```rust
+use nu_ansi_term::Style;
+use nu_ansi_term::Color::{Blue, Cyan, Yellow};
+
+println!("Yellow on blue: {}", Style::new().on(Blue).fg(Yellow).paint("yow!"));
+println!("Also yellow on blue: {}", Cyan.on(Blue).fg(Yellow).paint("zow!"));
+```
+
+You can turn a `Color` into a `Style` with the `normal` method.
+This will produce the exact same `ANSIString` as if you just used the `paint` method on the `Color` directly, but it’s useful in certain cases: for example, you may have a method that returns `Styles`, and need to represent both the “red bold” and “red, but not bold” styles with values of the same type. The `Style` struct also has a `Default` implementation if you want to have a style with _nothing_ set.
+
+```rust
+use nu_ansi_term::Style;
+use nu_ansi_term::Color::Red;
+
+Red.normal().paint("yet another red string");
+Style::default().paint("a completely regular string");
+```
+
+## Extended colors
+
+You can access the extended range of 256 colors by using the `Color::Fixed` variant, which takes an argument of the color number to use.
+This can be included wherever you would use a `Color`:
+
+```rust
+use nu_ansi_term::Color::Fixed;
+
+Fixed(134).paint("A sort of light purple");
+Fixed(221).on(Fixed(124)).paint("Mustard in the ketchup");
+```
+
+The first sixteen of these values are the same as the normal and bold standard color variants.
+There’s nothing stopping you from using these as `Fixed` colors instead, but there’s nothing to be gained by doing so either.
+
+You can also access full 24-bit color by using the `Color::RGB` variant, which takes separate `u8` arguments for red, green, and blue:
+
+```rust
+use nu_ansi_term::Color::RGB;
+
+RGB(70, 130, 180).paint("Steel blue");
+```
+
+## Combining successive coloured strings
+
+The benefit of writing ANSI escape codes to the terminal is that they _stack_: you do not need to end every coloured string with a reset code if the text that follows it is of a similar style.
+For example, if you want to have some blue text followed by some blue bold text, it’s possible to send the ANSI code for blue, followed by the ANSI code for bold, and finishing with a reset code without having to have an extra one between the two strings.
+
+This crate can optimise the ANSI codes that get printed in situations like this, making life easier for your terminal renderer.
+The `ANSIStrings` struct takes a slice of several `ANSIString` values, and will iterate over each of them, printing only the codes for the styles that need to be updated as part of its formatting routine.
+
+The following code snippet uses this to enclose a binary number displayed in red bold text inside some red, but not bold, brackets:
+
+```rust
+use nu_ansi_term::Color::Red;
+use nu_ansi_term::{ANSIString, ANSIStrings};
+
+let some_value = format!("{:b}", 42);
+let strings: &[ANSIString<'static>] = &[
+    Red.paint("["),
+    Red.bold().paint(some_value),
+    Red.paint("]"),
+];
+
+println!("Value: {}", ANSIStrings(strings));
+```
+
+There are several things to note here.
+Firstly, the `paint` method can take _either_ an owned `String` or a borrowed `&str`.
+Internally, an `ANSIString` holds a copy-on-write (`Cow`) string value to deal with both owned and borrowed strings at the same time.
+This is used here to display a `String`, the result of the `format!` call, using the same mechanism as some statically-available `&str` slices.
+Secondly, that the `ANSIStrings` value works in the same way as its singular counterpart, with a `Display` implementation that only performs the formatting when required.
+
+## Byte strings
+
+This library also supports formatting `[u8]` byte strings; this supports applications working with text in an unknown encoding.
+`Style` and `Color` support painting `[u8]` values, resulting in an `ANSIByteString`.
+This type does not implement `Display`, as it may not contain UTF-8, but it does provide a method `write_to` to write the result to any value that implements `Write`:
+
+```rust
+use nu_ansi_term::Color::Green;
+
+Green.paint("user data".as_bytes()).write_to(&mut std::io::stdout()).unwrap();
+```
+
+Similarly, the type `ANSIByteStrings` supports writing a list of `ANSIByteString` values with minimal escape sequences:
+
+```rust
+use nu_ansi_term::Color::Green;
+use nu_ansi_term::ANSIByteStrings;
+
+ANSIByteStrings(&[
+    Green.paint("user data 1\n".as_bytes()),
+    Green.bold().paint("user data 2\n".as_bytes()),
+]).write_to(&mut std::io::stdout()).unwrap();
+```

crates/nu-ansi-term/examples/256_colors.rs

@@ -0,0 +1,72 @@
+extern crate nu_ansi_term;
+use nu_ansi_term::Color;
+
+// This example prints out the 256 colors.
+// They're arranged like this:
+//
+// - 0 to 8 are the eight standard colors.
+// - 9 to 15 are the eight bold colors.
+// - 16 to 231 are six blocks of six-by-six color squares.
+// - 232 to 255 are shades of grey.
+
+fn main() {
+    // First two lines
+    for c in 0..8 {
+        glow(c, c != 0);
+        print!(" ");
+    }
+    println!();
+    for c in 8..16 {
+        glow(c, c != 8);
+        print!(" ");
+    }
+    println!("\n");
+
+    // Six lines of the first three squares
+    for row in 0..6 {
+        for square in 0..3 {
+            for column in 0..6 {
+                glow(16 + square * 36 + row * 6 + column, row >= 3);
+                print!(" ");
+            }
+
+            print!("  ");
+        }
+
+        println!();
+    }
+    println!();
+
+    // Six more lines of the other three squares
+    for row in 0..6 {
+        for square in 0..3 {
+            for column in 0..6 {
+                glow(124 + square * 36 + row * 6 + column, row >= 3);
+                print!(" ");
+            }
+
+            print!("  ");
+        }
+
+        println!();
+    }
+    println!();
+
+    // The last greyscale lines
+    for c in 232..=243 {
+        glow(c, false);
+        print!(" ");
+    }
+    println!();
+    for c in 244..=255 {
+        glow(c, true);
+        print!(" ");
+    }
+    println!();
+}
+
+fn glow(c: u8, light_bg: bool) {
+    let base = if light_bg { Color::Black } else { Color::White };
+    let style = base.on(Color::Fixed(c));
+    print!("{}", style.paint(&format!(" {:3} ", c)));
+}

crates/nu-ansi-term/examples/basic_colors.rs

@@ -0,0 +1,18 @@
+extern crate nu_ansi_term;
+use nu_ansi_term::{Color::*, Style};
+
+// This example prints out the 16 basic colors.
+
+fn main() {
+    let normal = Style::default();
+
+    println!("{} {}", normal.paint("Normal"), normal.bold().paint("bold"));
+    println!("{} {}", Black.paint("Black"), Black.bold().paint("bold"));
+    println!("{} {}", Red.paint("Red"), Red.bold().paint("bold"));
+    println!("{} {}", Green.paint("Green"), Green.bold().paint("bold"));
+    println!("{} {}", Yellow.paint("Yellow"), Yellow.bold().paint("bold"));
+    println!("{} {}", Blue.paint("Blue"), Blue.bold().paint("bold"));
+    println!("{} {}", Purple.paint("Purple"), Purple.bold().paint("bold"));
+    println!("{} {}", Cyan.paint("Cyan"), Cyan.bold().paint("bold"));
+    println!("{} {}", White.paint("White"), White.bold().paint("bold"));
+}

crates/nu-ansi-term/examples/gradient_colors.rs

@@ -0,0 +1,37 @@
+use nu_ansi_term::{build_all_gradient_text, Color, Gradient, Rgb, TargetGround};
+
+fn main() {
+    let text = "lorem ipsum quia dolor sit amet, consectetur, adipisci velit";
+
+    // a gradient from hex colors
+    let start = Rgb::from_hex(0x40c9ff);
+    let end = Rgb::from_hex(0xe81cff);
+    let grad0 = Gradient::new(start, end);
+
+    // a gradient from color::rgb()
+    let start = Color::Rgb(64, 201, 255);
+    let end = Color::Rgb(232, 28, 255);
+    let gradient = Gradient::from_color_rgb(start, end);
+
+    // a slightly different gradient
+    let start2 = Color::Rgb(128, 64, 255);
+    let end2 = Color::Rgb(0, 28, 255);
+    let gradient2 = Gradient::from_color_rgb(start2, end2);
+
+    // reverse the gradient
+    let gradient3 = gradient.reverse();
+
+    let build_fg = gradient.build(text, TargetGround::Foreground);
+    println!("{}", build_fg);
+    let build_bg = gradient.build(text, TargetGround::Background);
+    println!("{}", build_bg);
+    let bgt = build_all_gradient_text(text, gradient, gradient2);
+    println!("{}", bgt);
+    let bgt2 = build_all_gradient_text(text, gradient, gradient3);
+    println!("{}", bgt2);
+
+    println!(
+        "{}",
+        grad0.build("nushell is awesome", TargetGround::Foreground)
+    );
+}

crates/nu-ansi-term/examples/rgb_colors.rs

@@ -0,0 +1,23 @@
+extern crate nu_ansi_term;
+use nu_ansi_term::{Color, Style};
+
+// This example prints out a color gradient in a grid by calculating each
+// character’s red, green, and blue components, and using 24-bit color codes
+// to display them.
+
+const WIDTH: i32 = 80;
+const HEIGHT: i32 = 24;
+
+fn main() {
+    for row in 0..HEIGHT {
+        for col in 0..WIDTH {
+            let r = (row * 255 / HEIGHT) as u8;
+            let g = (col * 255 / WIDTH) as u8;
+            let b = 128;
+
+            print!("{}", Style::default().on(Color::Rgb(r, g, b)).paint(" "));
+        }
+
+        println!();
+    }
+}

crates/nu-ansi-term/src/ansi.rs

@@ -0,0 +1,405 @@
+#![allow(missing_docs)]
+use crate::style::{Color, Style};
+use crate::write::AnyWrite;
+use std::fmt;
+
+impl Style {
+    /// Write any bytes that go *before* a piece of text to the given writer.
+    fn write_prefix<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
+        // If there are actually no styles here, then don’t write *any* codes
+        // as the prefix. An empty ANSI code may not affect the terminal
+        // output at all, but a user may just want a code-free string.
+        if self.is_plain() {
+            return Ok(());
+        }
+
+        // Write the codes’ prefix, then write numbers, separated by
+        // semicolons, for each text style we want to apply.
+        write!(f, "\x1B[")?;
+        let mut written_anything = false;
+
+        {
+            let mut write_char = |c| {
+                if written_anything {
+                    write!(f, ";")?;
+                }
+                written_anything = true;
+                write!(f, "{}", c)?;
+                Ok(())
+            };
+
+            if self.is_bold {
+                write_char('1')?
+            }
+            if self.is_dimmed {
+                write_char('2')?
+            }
+            if self.is_italic {
+                write_char('3')?
+            }
+            if self.is_underline {
+                write_char('4')?
+            }
+            if self.is_blink {
+                write_char('5')?
+            }
+            if self.is_reverse {
+                write_char('7')?
+            }
+            if self.is_hidden {
+                write_char('8')?
+            }
+            if self.is_strikethrough {
+                write_char('9')?
+            }
+        }
+
+        // The foreground and background colors, if specified, need to be
+        // handled specially because the number codes are more complicated.
+        // (see `write_background_code` and `write_foreground_code`)
+        if let Some(bg) = self.background {
+            if written_anything {
+                write!(f, ";")?;
+            }
+            written_anything = true;
+            bg.write_background_code(f)?;
+        }
+
+        if let Some(fg) = self.foreground {
+            if written_anything {
+                write!(f, ";")?;
+            }
+            fg.write_foreground_code(f)?;
+        }
+
+        // All the codes end with an `m`, because reasons.
+        write!(f, "m")?;
+
+        Ok(())
+    }
+
+    /// Write any bytes that go *after* a piece of text to the given writer.
+    fn write_suffix<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
+        if self.is_plain() {
+            Ok(())
+        } else {
+            write!(f, "{}", RESET)
+        }
+    }
+}
+
+/// The code to send to reset all styles and return to `Style::default()`.
+pub static RESET: &str = "\x1B[0m";
+
+impl Color {
+    fn write_foreground_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
+        match self {
+            Color::Black => write!(f, "30"),
+            Color::Red => write!(f, "31"),
+            Color::Green => write!(f, "32"),
+            Color::Yellow => write!(f, "33"),
+            Color::Blue => write!(f, "34"),
+            Color::Purple => write!(f, "35"),
+            Color::Magenta => write!(f, "35"),
+            Color::Cyan => write!(f, "36"),
+            Color::White => write!(f, "37"),
+            Color::Fixed(num) => write!(f, "38;5;{}", num),
+            Color::Rgb(r, g, b) => write!(f, "38;2;{};{};{}", r, g, b),
+            Color::DarkGray => write!(f, "90"),
+            Color::LightRed => write!(f, "91"),
+            Color::LightGreen => write!(f, "92"),
+            Color::LightYellow => write!(f, "93"),
+            Color::LightBlue => write!(f, "94"),
+            Color::LightPurple => write!(f, "95"),
+            Color::LightMagenta => write!(f, "95"),
+            Color::LightCyan => write!(f, "96"),
+            Color::LightGray => write!(f, "97"),
+        }
+    }
+
+    fn write_background_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
+        match self {
+            Color::Black => write!(f, "40"),
+            Color::Red => write!(f, "41"),
+            Color::Green => write!(f, "42"),
+            Color::Yellow => write!(f, "43"),
+            Color::Blue => write!(f, "44"),
+            Color::Purple => write!(f, "45"),
+            Color::Magenta => write!(f, "45"),
+            Color::Cyan => write!(f, "46"),
+            Color::White => write!(f, "47"),
+            Color::Fixed(num) => write!(f, "48;5;{}", num),
+            Color::Rgb(r, g, b) => write!(f, "48;2;{};{};{}", r, g, b),
+            Color::DarkGray => write!(f, "100"),
+            Color::LightRed => write!(f, "101"),
+            Color::LightGreen => write!(f, "102"),
+            Color::LightYellow => write!(f, "103"),
+            Color::LightBlue => write!(f, "104"),
+            Color::LightPurple => write!(f, "105"),
+            Color::LightMagenta => write!(f, "105"),
+            Color::LightCyan => write!(f, "106"),
+            Color::LightGray => write!(f, "107"),
+        }
+    }
+}
+
+/// Like `ANSIString`, but only displays the style prefix.
+///
+/// This type implements the `Display` trait, meaning it can be written to a
+/// `std::fmt` formatting without doing any extra allocation, and written to a
+/// string with the `.to_string()` method. For examples, see
+/// [`Style::prefix`](struct.Style.html#method.prefix).
+#[derive(Clone, Copy, Debug)]
+pub struct Prefix(Style);
+
+/// Like `ANSIString`, but only displays the difference between two
+/// styles.
+///
+/// This type implements the `Display` trait, meaning it can be written to a
+/// `std::fmt` formatting without doing any extra allocation, and written to a
+/// string with the `.to_string()` method. For examples, see
+/// [`Style::infix`](struct.Style.html#method.infix).
+#[derive(Clone, Copy, Debug)]
+pub struct Infix(Style, Style);
+
+/// Like `ANSIString`, but only displays the style suffix.
+///
+/// This type implements the `Display` trait, meaning it can be written to a
+/// `std::fmt` formatting without doing any extra allocation, and written to a
+/// string with the `.to_string()` method. For examples, see
+/// [`Style::suffix`](struct.Style.html#method.suffix).
+#[derive(Clone, Copy, Debug)]
+pub struct Suffix(Style);
+
+impl Style {
+    /// The prefix bytes for this style. These are the bytes that tell the
+    /// terminal to use a different color or font style.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color::Blue};
+    ///
+    /// let style = Style::default().bold();
+    /// assert_eq!("\x1b[1m",
+    ///            style.prefix().to_string());
+    ///
+    /// let style = Blue.bold();
+    /// assert_eq!("\x1b[1;34m",
+    ///            style.prefix().to_string());
+    ///
+    /// let style = Style::default();
+    /// assert_eq!("",
+    ///            style.prefix().to_string());
+    /// ```
+    pub fn prefix(self) -> Prefix {
+        Prefix(self)
+    }
+
+    /// The infix bytes between this style and `next` style. These are the bytes
+    /// that tell the terminal to change the style to `next`. These may include
+    /// a reset followed by the next color and style, depending on the two styles.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color::Green};
+    ///
+    /// let style = Style::default().bold();
+    /// assert_eq!("\x1b[32m",
+    ///            style.infix(Green.bold()).to_string());
+    ///
+    /// let style = Green.normal();
+    /// assert_eq!("\x1b[1m",
+    ///            style.infix(Green.bold()).to_string());
+    ///
+    /// let style = Style::default();
+    /// assert_eq!("",
+    ///            style.infix(style).to_string());
+    /// ```
+    pub fn infix(self, next: Style) -> Infix {
+        Infix(self, next)
+    }
+
+    /// The suffix for this style. These are the bytes that tell the terminal
+    /// to reset back to its normal color and font style.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color::Green};
+    ///
+    /// let style = Style::default().bold();
+    /// assert_eq!("\x1b[0m",
+    ///            style.suffix().to_string());
+    ///
+    /// let style = Green.normal().bold();
+    /// assert_eq!("\x1b[0m",
+    ///            style.suffix().to_string());
+    ///
+    /// let style = Style::default();
+    /// assert_eq!("",
+    ///            style.suffix().to_string());
+    /// ```
+    pub fn suffix(self) -> Suffix {
+        Suffix(self)
+    }
+}
+
+impl Color {
+    /// The prefix bytes for this color as a `Style`. These are the bytes
+    /// that tell the terminal to use a different color or font style.
+    ///
+    /// See also [`Style::prefix`](struct.Style.html#method.prefix).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color::Green;
+    ///
+    /// assert_eq!("\x1b[0m",
+    ///            Green.suffix().to_string());
+    /// ```
+    pub fn prefix(self) -> Prefix {
+        Prefix(self.normal())
+    }
+
+    /// The infix bytes between this color and `next` color. These are the bytes
+    /// that tell the terminal to use the `next` color, or to do nothing if
+    /// the two colors are equal.
+    ///
+    /// See also [`Style::infix`](struct.Style.html#method.infix).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color::{Red, Yellow};
+    ///
+    /// assert_eq!("\x1b[33m",
+    ///            Red.infix(Yellow).to_string());
+    /// ```
+    pub fn infix(self, next: Color) -> Infix {
+        Infix(self.normal(), next.normal())
+    }
+
+    /// The suffix for this color as a `Style`. These are the bytes that
+    /// tell the terminal to reset back to its normal color and font style.
+    ///
+    /// See also [`Style::suffix`](struct.Style.html#method.suffix).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color::Purple;
+    ///
+    /// assert_eq!("\x1b[0m",
+    ///            Purple.suffix().to_string());
+    /// ```
+    pub fn suffix(self) -> Suffix {
+        Suffix(self.normal())
+    }
+}
+
+impl fmt::Display for Prefix {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let f: &mut dyn fmt::Write = f;
+        self.0.write_prefix(f)
+    }
+}
+
+impl fmt::Display for Infix {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use crate::difference::Difference;
+
+        match Difference::between(&self.0, &self.1) {
+            Difference::ExtraStyles(style) => {
+                let f: &mut dyn fmt::Write = f;
+                style.write_prefix(f)
+            }
+            Difference::Reset => {
+                let f: &mut dyn fmt::Write = f;
+                write!(f, "{}{}", RESET, self.1.prefix())
+            }
+            Difference::Empty => {
+                Ok(()) // nothing to write
+            }
+        }
+    }
+}
+
+impl fmt::Display for Suffix {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let f: &mut dyn fmt::Write = f;
+        self.0.write_suffix(f)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::style::Color::*;
+    use crate::style::Style;
+
+    macro_rules! test {
+        ($name: ident: $style: expr; $input: expr => $result: expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!($style.paint($input).to_string(), $result.to_string());
+
+                let mut v = Vec::new();
+                $style.paint($input.as_bytes()).write_to(&mut v).unwrap();
+                assert_eq!(v.as_slice(), $result.as_bytes());
+            }
+        };
+    }
+
+    test!(plain:                 Style::default();                  "text/plain" => "text/plain");
+    test!(red:                   Red;                               "hi" => "\x1B[31mhi\x1B[0m");
+    test!(black:                 Black.normal();                    "hi" => "\x1B[30mhi\x1B[0m");
+    test!(yellow_bold:           Yellow.bold();                     "hi" => "\x1B[1;33mhi\x1B[0m");
+    test!(yellow_bold_2:         Yellow.normal().bold();            "hi" => "\x1B[1;33mhi\x1B[0m");
+    test!(blue_underline:        Blue.underline();                  "hi" => "\x1B[4;34mhi\x1B[0m");
+    test!(green_bold_ul:         Green.bold().underline();          "hi" => "\x1B[1;4;32mhi\x1B[0m");
+    test!(green_bold_ul_2:       Green.underline().bold();          "hi" => "\x1B[1;4;32mhi\x1B[0m");
+    test!(purple_on_white:       Purple.on(White);                  "hi" => "\x1B[47;35mhi\x1B[0m");
+    test!(purple_on_white_2:     Purple.normal().on(White);         "hi" => "\x1B[47;35mhi\x1B[0m");
+    test!(yellow_on_blue:        Style::new().on(Blue).fg(Yellow);  "hi" => "\x1B[44;33mhi\x1B[0m");
+    test!(magenta_on_white:      Magenta.on(White);                  "hi" => "\x1B[47;35mhi\x1B[0m");
+    test!(magenta_on_white_2:    Magenta.normal().on(White);         "hi" => "\x1B[47;35mhi\x1B[0m");
+    test!(yellow_on_blue_2:      Cyan.on(Blue).fg(Yellow);          "hi" => "\x1B[44;33mhi\x1B[0m");
+    test!(cyan_bold_on_white:    Cyan.bold().on(White);             "hi" => "\x1B[1;47;36mhi\x1B[0m");
+    test!(cyan_ul_on_white:      Cyan.underline().on(White);        "hi" => "\x1B[4;47;36mhi\x1B[0m");
+    test!(cyan_bold_ul_on_white: Cyan.bold().underline().on(White); "hi" => "\x1B[1;4;47;36mhi\x1B[0m");
+    test!(cyan_ul_bold_on_white: Cyan.underline().bold().on(White); "hi" => "\x1B[1;4;47;36mhi\x1B[0m");
+    test!(fixed:                 Fixed(100);                        "hi" => "\x1B[38;5;100mhi\x1B[0m");
+    test!(fixed_on_purple:       Fixed(100).on(Purple);             "hi" => "\x1B[45;38;5;100mhi\x1B[0m");
+    test!(fixed_on_fixed:        Fixed(100).on(Fixed(200));         "hi" => "\x1B[48;5;200;38;5;100mhi\x1B[0m");
+    test!(rgb:                   Rgb(70,130,180);                   "hi" => "\x1B[38;2;70;130;180mhi\x1B[0m");
+    test!(rgb_on_blue:           Rgb(70,130,180).on(Blue);          "hi" => "\x1B[44;38;2;70;130;180mhi\x1B[0m");
+    test!(blue_on_rgb:           Blue.on(Rgb(70,130,180));          "hi" => "\x1B[48;2;70;130;180;34mhi\x1B[0m");
+    test!(rgb_on_rgb:            Rgb(70,130,180).on(Rgb(5,10,15));  "hi" => "\x1B[48;2;5;10;15;38;2;70;130;180mhi\x1B[0m");
+    test!(bold:                  Style::new().bold();               "hi" => "\x1B[1mhi\x1B[0m");
+    test!(underline:             Style::new().underline();          "hi" => "\x1B[4mhi\x1B[0m");
+    test!(bunderline:            Style::new().bold().underline();   "hi" => "\x1B[1;4mhi\x1B[0m");
+    test!(dimmed:                Style::new().dimmed();             "hi" => "\x1B[2mhi\x1B[0m");
+    test!(italic:                Style::new().italic();             "hi" => "\x1B[3mhi\x1B[0m");
+    test!(blink:                 Style::new().blink();              "hi" => "\x1B[5mhi\x1B[0m");
+    test!(reverse:               Style::new().reverse();            "hi" => "\x1B[7mhi\x1B[0m");
+    test!(hidden:                Style::new().hidden();             "hi" => "\x1B[8mhi\x1B[0m");
+    test!(stricken:              Style::new().strikethrough();      "hi" => "\x1B[9mhi\x1B[0m");
+    test!(lr_on_lr:              LightRed.on(LightRed);             "hi" => "\x1B[101;91mhi\x1B[0m");
+
+    #[test]
+    fn test_infix() {
+        assert_eq!(
+            Style::new().dimmed().infix(Style::new()).to_string(),
+            "\x1B[0m"
+        );
+        assert_eq!(
+            White.dimmed().infix(White.normal()).to_string(),
+            "\x1B[0m\x1B[37m"
+        );
+        assert_eq!(White.normal().infix(White.bold()).to_string(), "\x1B[1m");
+        assert_eq!(White.normal().infix(Blue.normal()).to_string(), "\x1B[34m");
+        assert_eq!(Blue.bold().infix(Blue.bold()).to_string(), "");
+    }
+}

crates/nu-ansi-term/src/debug.rs

@@ -0,0 +1,152 @@
+use crate::style::Style;
+use std::fmt;
+
+/// Styles have a special `Debug` implementation that only shows the fields that
+/// are set. Fields that haven’t been touched aren’t included in the output.
+///
+/// This behaviour gets bypassed when using the alternate formatting mode
+/// `format!("{:#?}")`.
+///
+///     use nu_ansi_term::Color::{Red, Blue};
+///     assert_eq!("Style { fg(Red), on(Blue), bold, italic }",
+///                format!("{:?}", Red.on(Blue).bold().italic()));
+impl fmt::Debug for Style {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        if fmt.alternate() {
+            fmt.debug_struct("Style")
+                .field("foreground", &self.foreground)
+                .field("background", &self.background)
+                .field("blink", &self.is_blink)
+                .field("bold", &self.is_bold)
+                .field("dimmed", &self.is_dimmed)
+                .field("hidden", &self.is_hidden)
+                .field("italic", &self.is_italic)
+                .field("reverse", &self.is_reverse)
+                .field("strikethrough", &self.is_strikethrough)
+                .field("underline", &self.is_underline)
+                .finish()
+        } else if self.is_plain() {
+            fmt.write_str("Style {}")
+        } else {
+            fmt.write_str("Style { ")?;
+
+            let mut written_anything = false;
+
+            if let Some(fg) = self.foreground {
+                if written_anything {
+                    fmt.write_str(", ")?
+                }
+                written_anything = true;
+                write!(fmt, "fg({:?})", fg)?
+            }
+
+            if let Some(bg) = self.background {
+                if written_anything {
+                    fmt.write_str(", ")?
+                }
+                written_anything = true;
+                write!(fmt, "on({:?})", bg)?
+            }
+
+            {
+                let mut write_flag = |name| {
+                    if written_anything {
+                        fmt.write_str(", ")?
+                    }
+                    written_anything = true;
+                    fmt.write_str(name)
+                };
+
+                if self.is_blink {
+                    write_flag("blink")?
+                }
+                if self.is_bold {
+                    write_flag("bold")?
+                }
+                if self.is_dimmed {
+                    write_flag("dimmed")?
+                }
+                if self.is_hidden {
+                    write_flag("hidden")?
+                }
+                if self.is_italic {
+                    write_flag("italic")?
+                }
+                if self.is_reverse {
+                    write_flag("reverse")?
+                }
+                if self.is_strikethrough {
+                    write_flag("strikethrough")?
+                }
+                if self.is_underline {
+                    write_flag("underline")?
+                }
+            }
+
+            write!(fmt, " }}")
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::style::Color::*;
+    use crate::style::Style;
+
+    fn style() -> Style {
+        Style::new()
+    }
+
+    macro_rules! test {
+        ($name: ident: $obj: expr => $result: expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!($result, format!("{:?}", $obj));
+            }
+        };
+    }
+
+    test!(empty:   style()                  => "Style {}");
+    test!(bold:    style().bold()           => "Style { bold }");
+    test!(italic:  style().italic()         => "Style { italic }");
+    test!(both:    style().bold().italic()  => "Style { bold, italic }");
+
+    test!(red:     Red.normal()                     => "Style { fg(Red) }");
+    test!(redblue: Red.normal().on(Rgb(3, 2, 4))    => "Style { fg(Red), on(Rgb(3, 2, 4)) }");
+
+    test!(everything:
+            Red.on(Blue).blink().bold().dimmed().hidden().italic().reverse().strikethrough().underline() =>
+            "Style { fg(Red), on(Blue), blink, bold, dimmed, hidden, italic, reverse, strikethrough, underline }");
+
+    #[test]
+    fn long_and_detailed() {
+        extern crate regex;
+        let expected_debug = "Style { fg(Blue), bold }";
+        let expected_pretty_repat = r##"(?x)
+        Style\s+\{\s+
+            foreground:\s+Some\(\s+
+                Blue,?\s+
+            \),\s+
+            background:\s+None,\s+
+            blink:\s+false,\s+
+            bold:\s+true,\s+
+            dimmed:\s+false,\s+
+            hidden:\s+false,\s+
+            italic:\s+false,\s+
+            reverse:\s+false,\s+
+            strikethrough:\s+
+            false,\s+
+            underline:\s+false,?\s+
+            \}"##;
+        let re = regex::Regex::new(expected_pretty_repat).unwrap();
+
+        let style = Blue.bold();
+        let style_fmt_debug = format!("{:?}", style);
+        let style_fmt_pretty = format!("{:#?}", style);
+        println!("style_fmt_debug:\n{}", style_fmt_debug);
+        println!("style_fmt_pretty:\n{}", style_fmt_pretty);
+
+        assert_eq!(expected_debug, style_fmt_debug);
+        assert!(re.is_match(&style_fmt_pretty));
+    }
+}

crates/nu-ansi-term/src/difference.rs

@@ -0,0 +1,174 @@
+use super::Style;
+
+/// When printing out one colored string followed by another, use one of
+/// these rules to figure out which *extra* control codes need to be sent.
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub enum Difference {
+    /// Print out the control codes specified by this style to end up looking
+    /// like the second string's styles.
+    ExtraStyles(Style),
+
+    /// Converting between these two is impossible, so just send a reset
+    /// command and then the second string's styles.
+    Reset,
+
+    /// The before style is exactly the same as the after style, so no further
+    /// control codes need to be printed.
+    Empty,
+}
+
+impl Difference {
+    /// Compute the 'style difference' required to turn an existing style into
+    /// the given, second style.
+    ///
+    /// For example, to turn green text into green bold text, it's redundant
+    /// to write a reset command then a second green+bold command, instead of
+    /// just writing one bold command. This method should see that both styles
+    /// use the foreground color green, and reduce it to a single command.
+    ///
+    /// This method returns an enum value because it's not actually always
+    /// possible to turn one style into another: for example, text could be
+    /// made bold and underlined, but you can't remove the bold property
+    /// without also removing the underline property. So when this has to
+    /// happen, this function returns None, meaning that the entire set of
+    /// styles should be reset and begun again.
+    pub fn between(first: &Style, next: &Style) -> Difference {
+        use self::Difference::*;
+
+        // XXX(Havvy): This algorithm is kind of hard to replicate without
+        // having the Plain/Foreground enum variants, so I'm just leaving
+        // it commented out for now, and defaulting to Reset.
+
+        if first == next {
+            return Empty;
+        }
+
+        // Cannot un-bold, so must Reset.
+        if first.is_bold && !next.is_bold {
+            return Reset;
+        }
+
+        if first.is_dimmed && !next.is_dimmed {
+            return Reset;
+        }
+
+        if first.is_italic && !next.is_italic {
+            return Reset;
+        }
+
+        // Cannot un-underline, so must Reset.
+        if first.is_underline && !next.is_underline {
+            return Reset;
+        }
+
+        if first.is_blink && !next.is_blink {
+            return Reset;
+        }
+
+        if first.is_reverse && !next.is_reverse {
+            return Reset;
+        }
+
+        if first.is_hidden && !next.is_hidden {
+            return Reset;
+        }
+
+        if first.is_strikethrough && !next.is_strikethrough {
+            return Reset;
+        }
+
+        // Cannot go from foreground to no foreground, so must Reset.
+        if first.foreground.is_some() && next.foreground.is_none() {
+            return Reset;
+        }
+
+        // Cannot go from background to no background, so must Reset.
+        if first.background.is_some() && next.background.is_none() {
+            return Reset;
+        }
+
+        let mut extra_styles = Style::default();
+
+        if first.is_bold != next.is_bold {
+            extra_styles.is_bold = true;
+        }
+
+        if first.is_dimmed != next.is_dimmed {
+            extra_styles.is_dimmed = true;
+        }
+
+        if first.is_italic != next.is_italic {
+            extra_styles.is_italic = true;
+        }
+
+        if first.is_underline != next.is_underline {
+            extra_styles.is_underline = true;
+        }
+
+        if first.is_blink != next.is_blink {
+            extra_styles.is_blink = true;
+        }
+
+        if first.is_reverse != next.is_reverse {
+            extra_styles.is_reverse = true;
+        }
+
+        if first.is_hidden != next.is_hidden {
+            extra_styles.is_hidden = true;
+        }
+
+        if first.is_strikethrough != next.is_strikethrough {
+            extra_styles.is_strikethrough = true;
+        }
+
+        if first.foreground != next.foreground {
+            extra_styles.foreground = next.foreground;
+        }
+
+        if first.background != next.background {
+            extra_styles.background = next.background;
+        }
+
+        ExtraStyles(extra_styles)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Difference::*;
+    use super::*;
+    use crate::style::Color::*;
+    use crate::style::Style;
+
+    fn style() -> Style {
+        Style::new()
+    }
+
+    macro_rules! test {
+        ($name: ident: $first: expr; $next: expr => $result: expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!($result, Difference::between(&$first, &$next));
+            }
+        };
+    }
+
+    test!(nothing:    Green.normal(); Green.normal()  => Empty);
+    test!(uppercase:  Green.normal(); Green.bold()    => ExtraStyles(style().bold()));
+    test!(lowercase:  Green.bold();   Green.normal()  => Reset);
+    test!(nothing2:   Green.bold();   Green.bold()    => Empty);
+
+    test!(color_change: Red.normal(); Blue.normal() => ExtraStyles(Blue.normal()));
+
+    test!(addition_of_blink:          style(); style().blink()          => ExtraStyles(style().blink()));
+    test!(addition_of_dimmed:         style(); style().dimmed()         => ExtraStyles(style().dimmed()));
+    test!(addition_of_hidden:         style(); style().hidden()         => ExtraStyles(style().hidden()));
+    test!(addition_of_reverse:        style(); style().reverse()        => ExtraStyles(style().reverse()));
+    test!(addition_of_strikethrough:  style(); style().strikethrough()  => ExtraStyles(style().strikethrough()));
+
+    test!(removal_of_strikethrough:   style().strikethrough(); style()  => Reset);
+    test!(removal_of_reverse:         style().reverse();       style()  => Reset);
+    test!(removal_of_hidden:          style().hidden();        style()  => Reset);
+    test!(removal_of_dimmed:          style().dimmed();        style()  => Reset);
+    test!(removal_of_blink:           style().blink();         style()  => Reset);
+}

crates/nu-ansi-term/src/display.rs

@@ -0,0 +1,303 @@
+use crate::ansi::RESET;
+use crate::difference::Difference;
+use crate::style::{Color, Style};
+use crate::write::AnyWrite;
+use std::borrow::Cow;
+use std::fmt;
+use std::io;
+use std::ops::Deref;
+
+/// An `ANSIGenericString` includes a generic string type and a `Style` to
+/// display that string.  `ANSIString` and `ANSIByteString` are aliases for
+/// this type on `str` and `\[u8]`, respectively.
+#[derive(PartialEq, Debug)]
+pub struct AnsiGenericString<'a, S: 'a + ToOwned + ?Sized>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+{
+    style: Style,
+    string: Cow<'a, S>,
+}
+
+/// Cloning an `ANSIGenericString` will clone its underlying string.
+///
+/// # Examples
+///
+/// ```
+/// use nu_ansi_term::ANSIString;
+///
+/// let plain_string = ANSIString::from("a plain string");
+/// let clone_string = plain_string.clone();
+/// assert_eq!(clone_string, plain_string);
+/// ```
+impl<'a, S: 'a + ToOwned + ?Sized> Clone for AnsiGenericString<'a, S>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+{
+    fn clone(&self) -> AnsiGenericString<'a, S> {
+        AnsiGenericString {
+            style: self.style,
+            string: self.string.clone(),
+        }
+    }
+}
+
+// You might think that the hand-written Clone impl above is the same as the
+// one that gets generated with #[derive]. But it’s not *quite* the same!
+//
+// `str` is not Clone, and the derived Clone implementation puts a Clone
+// constraint on the S type parameter (generated using --pretty=expanded):
+//
+//                  ↓_________________↓
+//     impl <'a, S: ::std::clone::Clone + 'a + ToOwned + ?Sized> ::std::clone::Clone
+//     for ANSIGenericString<'a, S> where
+//     <S as ToOwned>::Owned: fmt::Debug { ... }
+//
+// This resulted in compile errors when you tried to derive Clone on a type
+// that used it:
+//
+//     #[derive(PartialEq, Debug, Clone, Default)]
+//     pub struct TextCellContents(Vec<ANSIString<'static>>);
+//                                 ^^^^^^^^^^^^^^^^^^^^^^^^^
+//     error[E0277]: the trait `std::clone::Clone` is not implemented for `str`
+//
+// The hand-written impl above can ignore that constraint and still compile.
+
+/// An ANSI String is a string coupled with the `Style` to display it
+/// in a terminal.
+///
+/// Although not technically a string itself, it can be turned into
+/// one with the `to_string` method.
+///
+/// # Examples
+///
+/// ```
+/// use nu_ansi_term::ANSIString;
+/// use nu_ansi_term::Color::Red;
+///
+/// let red_string = Red.paint("a red string");
+/// println!("{}", red_string);
+/// ```
+///
+/// ```
+/// use nu_ansi_term::ANSIString;
+///
+/// let plain_string = ANSIString::from("a plain string");
+/// assert_eq!(&*plain_string, "a plain string");
+/// ```
+pub type AnsiString<'a> = AnsiGenericString<'a, str>;
+
+/// An `AnsiByteString` represents a formatted series of bytes.  Use
+/// `AnsiByteString` when styling text with an unknown encoding.
+pub type AnsiByteString<'a> = AnsiGenericString<'a, [u8]>;
+
+impl<'a, I, S: 'a + ToOwned + ?Sized> From<I> for AnsiGenericString<'a, S>
+where
+    I: Into<Cow<'a, S>>,
+    <S as ToOwned>::Owned: fmt::Debug,
+{
+    fn from(input: I) -> AnsiGenericString<'a, S> {
+        AnsiGenericString {
+            string: input.into(),
+            style: Style::default(),
+        }
+    }
+}
+
+impl<'a, S: 'a + ToOwned + ?Sized> AnsiGenericString<'a, S>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+{
+    /// Directly access the style
+    pub fn style_ref(&self) -> &Style {
+        &self.style
+    }
+
+    /// Directly access the style mutably
+    pub fn style_ref_mut(&mut self) -> &mut Style {
+        &mut self.style
+    }
+}
+
+impl<'a, S: 'a + ToOwned + ?Sized> Deref for AnsiGenericString<'a, S>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+{
+    type Target = S;
+
+    fn deref(&self) -> &S {
+        self.string.deref()
+    }
+}
+
+/// A set of `AnsiGenericStrings`s collected together, in order to be
+/// written with a minimum of control characters.
+#[derive(Debug, PartialEq)]
+pub struct AnsiGenericStrings<'a, S: 'a + ToOwned + ?Sized>(pub &'a [AnsiGenericString<'a, S>])
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+    S: PartialEq;
+
+/// A set of `AnsiString`s collected together, in order to be written with a
+/// minimum of control characters.
+pub type AnsiStrings<'a> = AnsiGenericStrings<'a, str>;
+
+/// A function to construct an `AnsiStrings` instance.
+#[allow(non_snake_case)]
+pub fn AnsiStrings<'a>(arg: &'a [AnsiString<'a>]) -> AnsiStrings<'a> {
+    AnsiGenericStrings(arg)
+}
+
+/// A set of `AnsiByteString`s collected together, in order to be
+/// written with a minimum of control characters.
+pub type AnsiByteStrings<'a> = AnsiGenericStrings<'a, [u8]>;
+
+/// A function to construct an `ANSIByteStrings` instance.
+#[allow(non_snake_case)]
+pub fn ANSIByteStrings<'a>(arg: &'a [AnsiByteString<'a>]) -> AnsiByteStrings<'a> {
+    AnsiGenericStrings(arg)
+}
+
+// ---- paint functions ----
+
+impl Style {
+    /// Paints the given text with this color, returning an ANSI string.
+    #[must_use]
+    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> AnsiGenericString<'a, S>
+    where
+        I: Into<Cow<'a, S>>,
+        <S as ToOwned>::Owned: fmt::Debug,
+    {
+        AnsiGenericString {
+            string: input.into(),
+            style: self,
+        }
+    }
+}
+
+impl Color {
+    /// Paints the given text with this color, returning an ANSI string.
+    /// This is a short-cut so you don’t have to use `Blue.normal()` just
+    /// to get blue text.
+    ///
+    /// ```
+    /// use nu_ansi_term::Color::Blue;
+    /// println!("{}", Blue.paint("da ba dee"));
+    /// ```
+    #[must_use]
+    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> AnsiGenericString<'a, S>
+    where
+        I: Into<Cow<'a, S>>,
+        <S as ToOwned>::Owned: fmt::Debug,
+    {
+        AnsiGenericString {
+            string: input.into(),
+            style: self.normal(),
+        }
+    }
+}
+
+// ---- writers for individual ANSI strings ----
+
+impl<'a> fmt::Display for AnsiString<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let w: &mut dyn fmt::Write = f;
+        self.write_to_any(w)
+    }
+}
+
+impl<'a> AnsiByteString<'a> {
+    /// Write an `ANSIByteString` to an `io::Write`.  This writes the escape
+    /// sequences for the associated `Style` around the bytes.
+    pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
+        let w: &mut dyn io::Write = w;
+        self.write_to_any(w)
+    }
+}
+
+impl<'a, S: 'a + ToOwned + ?Sized> AnsiGenericString<'a, S>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+    &'a S: AsRef<[u8]>,
+{
+    fn write_to_any<W: AnyWrite<Wstr = S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> {
+        write!(w, "{}", self.style.prefix())?;
+        w.write_str(self.string.as_ref())?;
+        write!(w, "{}", self.style.suffix())
+    }
+}
+
+// ---- writers for combined ANSI strings ----
+
+impl<'a> fmt::Display for AnsiStrings<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let f: &mut dyn fmt::Write = f;
+        self.write_to_any(f)
+    }
+}
+
+impl<'a> AnsiByteStrings<'a> {
+    /// Write `ANSIByteStrings` to an `io::Write`.  This writes the minimal
+    /// escape sequences for the associated `Style`s around each set of
+    /// bytes.
+    pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
+        let w: &mut dyn io::Write = w;
+        self.write_to_any(w)
+    }
+}
+
+impl<'a, S: 'a + ToOwned + ?Sized + PartialEq> AnsiGenericStrings<'a, S>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+    &'a S: AsRef<[u8]>,
+{
+    fn write_to_any<W: AnyWrite<Wstr = S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> {
+        use self::Difference::*;
+
+        let first = match self.0.first() {
+            None => return Ok(()),
+            Some(f) => f,
+        };
+
+        write!(w, "{}", first.style.prefix())?;
+        w.write_str(first.string.as_ref())?;
+
+        for window in self.0.windows(2) {
+            match Difference::between(&window[0].style, &window[1].style) {
+                ExtraStyles(style) => write!(w, "{}", style.prefix())?,
+                Reset => write!(w, "{}{}", RESET, window[1].style.prefix())?,
+                Empty => { /* Do nothing! */ }
+            }
+
+            w.write_str(&window[1].string)?;
+        }
+
+        // Write the final reset string after all of the ANSIStrings have been
+        // written, *except* if the last one has no styles, because it would
+        // have already been written by this point.
+        if let Some(last) = self.0.last() {
+            if !last.style.is_plain() {
+                write!(w, "{}", RESET)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+// ---- tests ----
+
+#[cfg(test)]
+mod tests {
+    pub use super::super::AnsiStrings;
+    pub use crate::style::Color::*;
+    pub use crate::style::Style;
+
+    #[test]
+    fn no_control_codes_for_plain() {
+        let one = Style::default().paint("one");
+        let two = Style::default().paint("two");
+        let output = AnsiStrings(&[one, two]).to_string();
+        assert_eq!(output, "onetwo");
+    }
+}

crates/nu-ansi-term/src/gradient.rs

@@ -0,0 +1,105 @@
+use crate::{rgb::Rgb, Color};
+
+/// Linear color gradient between two color stops
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Gradient {
+    /// Start Color of Gradient
+    pub start: Rgb,
+
+    /// End Color of Gradient
+    pub end: Rgb,
+}
+
+impl Gradient {
+    /// Creates a new [Gradient] with two [Rgb] colors, `start` and `end`
+    #[inline]
+    pub const fn new(start: Rgb, end: Rgb) -> Self {
+        Self { start, end }
+    }
+    pub const fn from_color_rgb(start: Color, end: Color) -> Self {
+        let start_grad = match start {
+            Color::Rgb(r, g, b) => Rgb { r, g, b },
+            _ => Rgb { r: 0, g: 0, b: 0 },
+        };
+        let end_grad = match end {
+            Color::Rgb(r, g, b) => Rgb { r, g, b },
+            _ => Rgb { r: 0, g: 0, b: 0 },
+        };
+
+        Self {
+            start: start_grad,
+            end: end_grad,
+        }
+    }
+
+    /// Computes the [Rgb] color between `start` and `end` for `t`
+    pub fn at(&self, t: f32) -> Rgb {
+        self.start.lerp(self.end, t)
+    }
+
+    /// Returns the reverse of `self`
+    #[inline]
+    pub const fn reverse(&self) -> Self {
+        Self::new(self.end, self.start)
+    }
+
+    #[allow(dead_code)]
+    pub fn build(&self, text: &str, target: TargetGround) -> String {
+        let delta = 1.0 / text.len() as f32;
+        let mut result = text.char_indices().fold(String::new(), |mut acc, (i, c)| {
+            let temp = format!(
+                "\x1B[{}m{}",
+                self.at(i as f32 * delta).ansi_color_code(target),
+                c
+            );
+            acc.push_str(&temp);
+            acc
+        });
+
+        result.push_str("\x1B[0m");
+        result
+    }
+}
+
+#[allow(dead_code)]
+pub fn build_all_gradient_text(text: &str, foreground: Gradient, background: Gradient) -> String {
+    let delta = 1.0 / text.len() as f32;
+    let mut result = text.char_indices().fold(String::new(), |mut acc, (i, c)| {
+        let step = i as f32 * delta;
+        let temp = format!(
+            "\x1B[{};{}m{}",
+            foreground
+                .at(step)
+                .ansi_color_code(TargetGround::Foreground),
+            background
+                .at(step)
+                .ansi_color_code(TargetGround::Background),
+            c
+        );
+        acc.push_str(&temp);
+        acc
+    });
+
+    result.push_str("\x1B[0m");
+    result
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TargetGround {
+    Foreground,
+    Background,
+}
+
+impl TargetGround {
+    #[inline]
+    pub const fn code(&self) -> u8 {
+        match self {
+            Self::Foreground => 30,
+            Self::Background => 40,
+        }
+    }
+}
+
+pub trait ANSIColorCode {
+    fn ansi_color_code(&self, target: TargetGround) -> String;
+}

crates/nu-ansi-term/src/lib.rs

@@ -0,0 +1,273 @@
+//! This is a library for controlling colors and formatting, such as
+//! red bold text or blue underlined text, on ANSI terminals.
+//!
+//!
+//! ## Basic usage
+//!
+//! There are three main types in this crate that you need to be
+//! concerned with: [`ANSIString`], [`Style`], and [`Color`].
+//!
+//! A `Style` holds stylistic information: foreground and background colors,
+//! whether the text should be bold, or blinking, or other properties. The
+//! [`Color`] enum represents the available colors. And an [`ANSIString`] is a
+//! string paired with a [`Style`].
+//!
+//! [`Color`] is also available as an alias to `Color`.
+//!
+//! To format a string, call the `paint` method on a `Style` or a `Color`,
+//! passing in the string you want to format as the argument. For example,
+//! here’s how to get some red text:
+//!
+//! ```
+//! use nu_ansi_term::Color::Red;
+//!
+//! println!("This is in red: {}", Red.paint("a red string"));
+//! ```
+//!
+//! It’s important to note that the `paint` method does *not* actually return a
+//! string with the ANSI control characters surrounding it. Instead, it returns
+//! an [`ANSIString`] value that has a [`Display`] implementation that, when
+//! formatted, returns the characters. This allows strings to be printed with a
+//! minimum of [`String`] allocations being performed behind the scenes.
+//!
+//! If you *do* want to get at the escape codes, then you can convert the
+//! [`ANSIString`] to a string as you would any other `Display` value:
+//!
+//! ```
+//! use nu_ansi_term::Color::Red;
+//!
+//! let red_string = Red.paint("a red string").to_string();
+//! ```
+//!
+//!
+//! ## Bold, underline, background, and other styles
+//!
+//! For anything more complex than plain foreground color changes, you need to
+//! construct `Style` values themselves, rather than beginning with a `Color`.
+//! You can do this by chaining methods based on a new `Style`, created with
+//! [`Style::new()`]. Each method creates a new style that has that specific
+//! property set. For example:
+//!
+//! ```
+//! use nu_ansi_term::Style;
+//!
+//! println!("How about some {} and {}?",
+//!          Style::new().bold().paint("bold"),
+//!          Style::new().underline().paint("underline"));
+//! ```
+//!
+//! For brevity, these methods have also been implemented for `Color` values,
+//! so you can give your styles a foreground color without having to begin with
+//! an empty `Style` value:
+//!
+//! ```
+//! use nu_ansi_term::Color::{Blue, Yellow};
+//!
+//! println!("Demonstrating {} and {}!",
+//!          Blue.bold().paint("blue bold"),
+//!          Yellow.underline().paint("yellow underline"));
+//!
+//! println!("Yellow on blue: {}", Yellow.on(Blue).paint("wow!"));
+//! ```
+//!
+//! The complete list of styles you can use are: [`bold`], [`dimmed`], [`italic`],
+//! [`underline`], [`blink`], [`reverse`], [`hidden`], [`strikethrough`], and [`on`] for
+//! background colors.
+//!
+//! In some cases, you may find it easier to change the foreground on an
+//! existing `Style` rather than starting from the appropriate `Color`.
+//! You can do this using the [`fg`] method:
+//!
+//! ```
+//! use nu_ansi_term::Style;
+//! use nu_ansi_term::Color::{Blue, Cyan, Yellow};
+//!
+//! println!("Yellow on blue: {}", Style::new().on(Blue).fg(Yellow).paint("yow!"));
+//! println!("Also yellow on blue: {}", Cyan.on(Blue).fg(Yellow).paint("zow!"));
+//! ```
+//!
+//! You can turn a `Color` into a `Style` with the [`normal`] method.
+//! This will produce the exact same `ANSIString` as if you just used the
+//! `paint` method on the `Color` directly, but it’s useful in certain cases:
+//! for example, you may have a method that returns `Styles`, and need to
+//! represent both the “red bold” and “red, but not bold” styles with values of
+//! the same type. The `Style` struct also has a [`Default`] implementation if you
+//! want to have a style with *nothing* set.
+//!
+//! ```
+//! use nu_ansi_term::Style;
+//! use nu_ansi_term::Color::Red;
+//!
+//! Red.normal().paint("yet another red string");
+//! Style::default().paint("a completely regular string");
+//! ```
+//!
+//!
+//! ## Extended colors
+//!
+//! You can access the extended range of 256 colors by using the `Color::Fixed`
+//! variant, which takes an argument of the color number to use. This can be
+//! included wherever you would use a `Color`:
+//!
+//! ```
+//! use nu_ansi_term::Color::Fixed;
+//!
+//! Fixed(134).paint("A sort of light purple");
+//! Fixed(221).on(Fixed(124)).paint("Mustard in the ketchup");
+//! ```
+//!
+//! The first sixteen of these values are the same as the normal and bold
+//! standard color variants. There’s nothing stopping you from using these as
+//! `Fixed` colors instead, but there’s nothing to be gained by doing so
+//! either.
+//!
+//! You can also access full 24-bit color by using the `Color::Rgb` variant,
+//! which takes separate `u8` arguments for red, green, and blue:
+//!
+//! ```
+//! use nu_ansi_term::Color::Rgb;
+//!
+//! Rgb(70, 130, 180).paint("Steel blue");
+//! ```
+//!
+//! ## Combining successive colored strings
+//!
+//! The benefit of writing ANSI escape codes to the terminal is that they
+//! *stack*: you do not need to end every colored string with a reset code if
+//! the text that follows it is of a similar style. For example, if you want to
+//! have some blue text followed by some blue bold text, it’s possible to send
+//! the ANSI code for blue, followed by the ANSI code for bold, and finishing
+//! with a reset code without having to have an extra one between the two
+//! strings.
+//!
+//! This crate can optimise the ANSI codes that get printed in situations like
+//! this, making life easier for your terminal renderer. The [`ANSIStrings`]
+//! type takes a slice of several [`ANSIString`] values, and will iterate over
+//! each of them, printing only the codes for the styles that need to be updated
+//! as part of its formatting routine.
+//!
+//! The following code snippet uses this to enclose a binary number displayed in
+//! red bold text inside some red, but not bold, brackets:
+//!
+//! ```
+//! use nu_ansi_term::Color::Red;
+//! use nu_ansi_term::{ANSIString, ANSIStrings};
+//!
+//! let some_value = format!("{:b}", 42);
+//! let strings: &[ANSIString<'static>] = &[
+//!     Red.paint("["),
+//!     Red.bold().paint(some_value),
+//!     Red.paint("]"),
+//! ];
+//!
+//! println!("Value: {}", ANSIStrings(strings));
+//! ```
+//!
+//! There are several things to note here. Firstly, the [`paint`] method can take
+//! *either* an owned [`String`] or a borrowed [`&str`]. Internally, an [`ANSIString`]
+//! holds a copy-on-write ([`Cow`]) string value to deal with both owned and
+//! borrowed strings at the same time. This is used here to display a `String`,
+//! the result of the `format!` call, using the same mechanism as some
+//! statically-available `&str` slices. Secondly, that the [`ANSIStrings`] value
+//! works in the same way as its singular counterpart, with a [`Display`]
+//! implementation that only performs the formatting when required.
+//!
+//! ## Byte strings
+//!
+//! This library also supports formatting `\[u8]` byte strings; this supports
+//! applications working with text in an unknown encoding.  [`Style`] and
+//! [`Color`] support painting `\[u8]` values, resulting in an [`ANSIByteString`].
+//! This type does not implement [`Display`], as it may not contain UTF-8, but
+//! it does provide a method [`write_to`] to write the result to any value that
+//! implements [`Write`]:
+//!
+//! ```
+//! use nu_ansi_term::Color::Green;
+//!
+//! Green.paint("user data".as_bytes()).write_to(&mut std::io::stdout()).unwrap();
+//! ```
+//!
+//! Similarly, the type [`ANSIByteStrings`] supports writing a list of
+//! [`ANSIByteString`] values with minimal escape sequences:
+//!
+//! ```
+//! use nu_ansi_term::Color::Green;
+//! use nu_ansi_term::ANSIByteStrings;
+//!
+//! ANSIByteStrings(&[
+//!     Green.paint("user data 1\n".as_bytes()),
+//!     Green.bold().paint("user data 2\n".as_bytes()),
+//! ]).write_to(&mut std::io::stdout()).unwrap();
+//! ```
+//!
+//! [`Cow`]: https://doc.rust-lang.org/std/borrow/enum.Cow.html
+//! [`Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html
+//! [`Default`]: https://doc.rust-lang.org/std/default/trait.Default.html
+//! [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
+//! [`&str`]: https://doc.rust-lang.org/std/primitive.str.html
+//! [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
+//! [`Style`]: struct.Style.html
+//! [`Style::new()`]: struct.Style.html#method.new
+//! [`Color`]: enum.Color.html
+//! [`Color`]: enum.Color.html
+//! [`ANSIString`]: type.ANSIString.html
+//! [`ANSIStrings`]: type.ANSIStrings.html
+//! [`ANSIByteString`]: type.ANSIByteString.html
+//! [`ANSIByteStrings`]: type.ANSIByteStrings.html
+//! [`write_to`]: type.ANSIByteString.html#method.write_to
+//! [`paint`]: type.ANSIByteString.html#method.write_to
+//! [`normal`]: enum.Color.html#method.normal
+//!
+//! [`bold`]: struct.Style.html#method.bold
+//! [`dimmed`]: struct.Style.html#method.dimmed
+//! [`italic`]: struct.Style.html#method.italic
+//! [`underline`]: struct.Style.html#method.underline
+//! [`blink`]: struct.Style.html#method.blink
+//! [`reverse`]: struct.Style.html#method.reverse
+//! [`hidden`]: struct.Style.html#method.hidden
+//! [`strikethrough`]: struct.Style.html#method.strikethrough
+//! [`fg`]: struct.Style.html#method.fg
+//! [`on`]: struct.Style.html#method.on
+
+#![crate_name = "nu_ansi_term"]
+#![crate_type = "rlib"]
+#![crate_type = "dylib"]
+#![warn(missing_copy_implementations)]
+// #![warn(missing_docs)]
+#![warn(trivial_casts, trivial_numeric_casts)]
+// #![warn(unused_extern_crates, unused_qualifications)]
+
+#[cfg(target_os = "windows")]
+extern crate winapi;
+#[cfg(test)]
+#[macro_use]
+extern crate doc_comment;
+
+#[cfg(test)]
+doctest!("../README.md");
+
+pub mod ansi;
+pub use ansi::{Infix, Prefix, Suffix};
+
+mod style;
+pub use style::{Color, Style};
+
+mod difference;
+mod display;
+pub use display::*;
+
+mod write;
+
+mod windows;
+pub use windows::*;
+
+mod util;
+pub use util::*;
+
+mod debug;
+
+pub mod gradient;
+pub use gradient::*;
+
+mod rgb;
+pub use rgb::*;

crates/nu-ansi-term/src/rgb.rs

@@ -0,0 +1,173 @@
+// Code liberally borrowed from here
+// https://github.com/navierr/coloriz
+use std::ops;
+use std::u32;
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Rgb {
+    /// Red
+    pub r: u8,
+    /// Green
+    pub g: u8,
+    /// Blue
+    pub b: u8,
+}
+
+impl Rgb {
+    /// Creates a new [Rgb] color
+    #[inline]
+    pub const fn new(r: u8, g: u8, b: u8) -> Self {
+        Self { r, g, b }
+    }
+
+    /// Creates a new [Rgb] color with a hex code
+    #[inline]
+    pub const fn from_hex(hex: u32) -> Self {
+        Self::new((hex >> 16) as u8, (hex >> 8) as u8, hex as u8)
+    }
+
+    pub fn from_hex_string(hex: String) -> Self {
+        if hex.chars().count() == 8 && hex.starts_with("0x") {
+            // eprintln!("hex:{:?}", hex);
+            let (_, value_string) = hex.split_at(2);
+            // eprintln!("value_string:{:?}", value_string);
+            let int_val = u64::from_str_radix(value_string, 16);
+            match int_val {
+                Ok(num) => Self::new(
+                    ((num & 0xff0000) >> 16) as u8,
+                    ((num & 0xff00) >> 8) as u8,
+                    (num & 0xff) as u8,
+                ),
+                // Don't fail, just make the color black
+                // Should we fail?
+                _ => Self::new(0, 0, 0),
+            }
+        } else {
+            // Don't fail, just make the color black.
+            // Should we fail?
+            Self::new(0, 0, 0)
+        }
+    }
+
+    /// Creates a new [Rgb] color with three [f32] values
+    pub fn from_f32(r: f32, g: f32, b: f32) -> Self {
+        Self::new(
+            (r.clamp(0.0, 1.0) * 255.0) as u8,
+            (g.clamp(0.0, 1.0) * 255.0) as u8,
+            (b.clamp(0.0, 1.0) * 255.0) as u8,
+        )
+    }
+
+    /// Creates a grayscale [Rgb] color
+    #[inline]
+    pub const fn gray(x: u8) -> Self {
+        Self::new(x, x, x)
+    }
+
+    /// Creates a grayscale [Rgb] color with a [f32] value
+    pub fn gray_f32(x: f32) -> Self {
+        Self::from_f32(x, x, x)
+    }
+
+    /// Creates a new [Rgb] color from a [HSL] color
+    // pub fn from_hsl(hsl: HSL) -> Self {
+    //     if hsl.s == 0.0 {
+    //         return Self::gray_f32(hsl.l);
+    //     }
+
+    //     let q = if hsl.l < 0.5 {
+    //         hsl.l * (1.0 + hsl.s)
+    //     } else {
+    //         hsl.l + hsl.s - hsl.l * hsl.s
+    //     };
+    //     let p = 2.0 * hsl.l - q;
+    //     let h2c = |t: f32| {
+    //         let t = t.clamp(0.0, 1.0);
+    //         if 6.0 * t < 1.0 {
+    //             p + 6.0 * (q - p) * t
+    //         } else if t < 0.5 {
+    //             q
+    //         } else if 1.0 < 1.5 * t {
+    //             p + 6.0 * (q - p) * (1.0 / 1.5 - t)
+    //         } else {
+    //             p
+    //         }
+    //     };
+
+    //     Self::from_f32(h2c(hsl.h + 1.0 / 3.0), h2c(hsl.h), h2c(hsl.h - 1.0 / 3.0))
+    // }
+
+    /// Computes the linear interpolation between `self` and `other` for `t`
+    pub fn lerp(&self, other: Self, t: f32) -> Self {
+        let t = t.clamp(0.0, 1.0);
+        self * (1.0 - t) + other * t
+    }
+}
+
+impl From<(u8, u8, u8)> for Rgb {
+    fn from((r, g, b): (u8, u8, u8)) -> Self {
+        Self::new(r, g, b)
+    }
+}
+
+impl From<(f32, f32, f32)> for Rgb {
+    fn from((r, g, b): (f32, f32, f32)) -> Self {
+        Self::from_f32(r, g, b)
+    }
+}
+
+use crate::ANSIColorCode;
+use crate::TargetGround;
+impl ANSIColorCode for Rgb {
+    fn ansi_color_code(&self, target: TargetGround) -> String {
+        format!("{};2;{};{};{}", target.code() + 8, self.r, self.g, self.b)
+    }
+}
+
+overload::overload!(
+    (lhs: ?Rgb) + (rhs: ?Rgb) -> Rgb {
+        Rgb::new(
+            lhs.r.saturating_add(rhs.r),
+            lhs.g.saturating_add(rhs.g),
+            lhs.b.saturating_add(rhs.b)
+        )
+    }
+);
+
+overload::overload!(
+    (lhs: ?Rgb) - (rhs: ?Rgb) -> Rgb {
+        Rgb::new(
+            lhs.r.saturating_sub(rhs.r),
+            lhs.g.saturating_sub(rhs.g),
+            lhs.b.saturating_sub(rhs.b)
+        )
+    }
+);
+
+overload::overload!(
+    (lhs: ?Rgb) * (rhs: ?f32) -> Rgb {
+        Rgb::new(
+            (lhs.r as f32 * rhs.clamp(0.0, 1.0)) as u8,
+            (lhs.g as f32 * rhs.clamp(0.0, 1.0)) as u8,
+            (lhs.b as f32 * rhs.clamp(0.0, 1.0)) as u8
+        )
+    }
+);
+
+overload::overload!(
+    (lhs: ?f32) * (rhs: ?Rgb) -> Rgb {
+        Rgb::new(
+            (rhs.r as f32 * lhs.clamp(0.0, 1.0)) as u8,
+            (rhs.g as f32 * lhs.clamp(0.0, 1.0)) as u8,
+            (rhs.b as f32 * lhs.clamp(0.0, 1.0)) as u8
+        )
+    }
+);
+
+overload::overload!(
+    -(rgb: ?Rgb) -> Rgb {
+        Rgb::new(
+            255 - rgb.r,
+            255 - rgb.g,
+            255 - rgb.b)
+    }
+);

crates/nu-ansi-term/src/style.rs

@@ -0,0 +1,626 @@
+/// A style is a collection of properties that can format a string
+/// using ANSI escape codes.
+///
+/// # Examples
+///
+/// ```
+/// use nu_ansi_term::{Style, Color};
+///
+/// let style = Style::new().bold().on(Color::Black);
+/// println!("{}", style.paint("Bold on black"));
+/// ```
+#[derive(PartialEq, Clone, Copy)]
+#[cfg_attr(
+    feature = "derive_serde_style",
+    derive(serde::Deserialize, serde::Serialize)
+)]
+pub struct Style {
+    /// The style's foreground color, if it has one.
+    pub foreground: Option<Color>,
+
+    /// The style's background color, if it has one.
+    pub background: Option<Color>,
+
+    /// Whether this style is bold.
+    pub is_bold: bool,
+
+    /// Whether this style is dimmed.
+    pub is_dimmed: bool,
+
+    /// Whether this style is italic.
+    pub is_italic: bool,
+
+    /// Whether this style is underlined.
+    pub is_underline: bool,
+
+    /// Whether this style is blinking.
+    pub is_blink: bool,
+
+    /// Whether this style has reverse colors.
+    pub is_reverse: bool,
+
+    /// Whether this style is hidden.
+    pub is_hidden: bool,
+
+    /// Whether this style is struckthrough.
+    pub is_strikethrough: bool,
+}
+
+impl Style {
+    /// Creates a new Style with no properties set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new();
+    /// println!("{}", style.paint("hi"));
+    /// ```
+    pub fn new() -> Style {
+        Style::default()
+    }
+
+    /// Returns a `Style` with the bold property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().bold();
+    /// println!("{}", style.paint("hey"));
+    /// ```
+    pub fn bold(&self) -> Style {
+        Style {
+            is_bold: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the dimmed property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().dimmed();
+    /// println!("{}", style.paint("sup"));
+    /// ```
+    pub fn dimmed(&self) -> Style {
+        Style {
+            is_dimmed: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the italic property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().italic();
+    /// println!("{}", style.paint("greetings"));
+    /// ```
+    pub fn italic(&self) -> Style {
+        Style {
+            is_italic: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the underline property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().underline();
+    /// println!("{}", style.paint("salutations"));
+    /// ```
+    pub fn underline(&self) -> Style {
+        Style {
+            is_underline: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the blink property set.
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().blink();
+    /// println!("{}", style.paint("wazzup"));
+    /// ```
+    pub fn blink(&self) -> Style {
+        Style {
+            is_blink: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the reverse property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().reverse();
+    /// println!("{}", style.paint("aloha"));
+    /// ```
+    pub fn reverse(&self) -> Style {
+        Style {
+            is_reverse: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the hidden property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().hidden();
+    /// println!("{}", style.paint("ahoy"));
+    /// ```
+    pub fn hidden(&self) -> Style {
+        Style {
+            is_hidden: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the strikethrough property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().strikethrough();
+    /// println!("{}", style.paint("yo"));
+    /// ```
+    pub fn strikethrough(&self) -> Style {
+        Style {
+            is_strikethrough: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the foreground color property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color};
+    ///
+    /// let style = Style::new().fg(Color::Yellow);
+    /// println!("{}", style.paint("hi"));
+    /// ```
+    pub fn fg(&self, foreground: Color) -> Style {
+        Style {
+            foreground: Some(foreground),
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the background color property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color};
+    ///
+    /// let style = Style::new().on(Color::Blue);
+    /// println!("{}", style.paint("eyyyy"));
+    /// ```
+    pub fn on(&self, background: Color) -> Style {
+        Style {
+            background: Some(background),
+            ..*self
+        }
+    }
+
+    /// Return true if this `Style` has no actual styles, and can be written
+    /// without any control characters.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// assert_eq!(true,  Style::default().is_plain());
+    /// assert_eq!(false, Style::default().bold().is_plain());
+    /// ```
+    pub fn is_plain(self) -> bool {
+        self == Style::default()
+    }
+}
+
+impl Default for Style {
+    /// Returns a style with *no* properties set. Formatting text using this
+    /// style returns the exact same text.
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    /// assert_eq!(None,  Style::default().foreground);
+    /// assert_eq!(None,  Style::default().background);
+    /// assert_eq!(false, Style::default().is_bold);
+    /// assert_eq!("txt", Style::default().paint("txt").to_string());
+    /// ```
+    fn default() -> Style {
+        Style {
+            foreground: None,
+            background: None,
+            is_bold: false,
+            is_dimmed: false,
+            is_italic: false,
+            is_underline: false,
+            is_blink: false,
+            is_reverse: false,
+            is_hidden: false,
+            is_strikethrough: false,
+        }
+    }
+}
+
+// ---- colors ----
+
+/// A color is one specific type of ANSI escape code, and can refer
+/// to either the foreground or background color.
+///
+/// These use the standard numeric sequences.
+/// See <http://invisible-island.net/xterm/ctlseqs/ctlseqs.html>
+#[derive(PartialEq, Clone, Copy, Debug)]
+#[cfg_attr(
+    feature = "derive_serde_style",
+    derive(serde::Deserialize, serde::Serialize)
+)]
+pub enum Color {
+    /// Color #0 (foreground code `30`, background code `40`).
+    ///
+    /// This is not necessarily the background color, and using it as one may
+    /// render the text hard to read on terminals with dark backgrounds.
+    Black,
+
+    /// Color #0 (foreground code `90`, background code `100`).
+    DarkGray,
+
+    /// Color #1 (foreground code `31`, background code `41`).
+    Red,
+
+    /// Color #1 (foreground code `91`, background code `101`).
+    LightRed,
+
+    /// Color #2 (foreground code `32`, background code `42`).
+    Green,
+
+    /// Color #2 (foreground code `92`, background code `102`).
+    LightGreen,
+
+    /// Color #3 (foreground code `33`, background code `43`).
+    Yellow,
+
+    /// Color #3 (foreground code `93`, background code `103`).
+    LightYellow,
+
+    /// Color #4 (foreground code `34`, background code `44`).
+    Blue,
+
+    /// Color #4 (foreground code `94`, background code `104`).
+    LightBlue,
+
+    /// Color #5 (foreground code `35`, background code `45`).
+    Purple,
+
+    /// Color #5 (foreground code `95`, background code `105`).
+    LightPurple,
+
+    /// Color #5 (foreground code `35`, background code `45`).
+    Magenta,
+
+    /// Color #5 (foreground code `95`, background code `105`).
+    LightMagenta,
+
+    /// Color #6 (foreground code `36`, background code `46`).
+    Cyan,
+
+    /// Color #6 (foreground code `96`, background code `106`).
+    LightCyan,
+
+    /// Color #7 (foreground code `37`, background code `47`).
+    ///
+    /// As above, this is not necessarily the foreground color, and may be
+    /// hard to read on terminals with light backgrounds.
+    White,
+
+    /// Color #7 (foreground code `97`, background code `107`).
+    LightGray,
+
+    /// A color number from 0 to 255, for use in 256-color terminal
+    /// environments.
+    ///
+    /// - colors 0 to 7 are the `Black` to `White` variants respectively.
+    ///   These colors can usually be changed in the terminal emulator.
+    /// - colors 8 to 15 are brighter versions of the eight colors above.
+    ///   These can also usually be changed in the terminal emulator, or it
+    ///   could be configured to use the original colors and show the text in
+    ///   bold instead. It varies depending on the program.
+    /// - colors 16 to 231 contain several palettes of bright colors,
+    ///   arranged in six squares measuring six by six each.
+    /// - colors 232 to 255 are shades of grey from black to white.
+    ///
+    /// It might make more sense to look at a [color chart][cc].
+    ///
+    /// [cc]: https://upload.wikimedia.org/wikipedia/commons/1/15/Xterm_256color_chart.svg
+    Fixed(u8),
+
+    /// A 24-bit Rgb color, as specified by ISO-8613-3.
+    Rgb(u8, u8, u8),
+}
+
+impl Default for Color {
+    fn default() -> Self {
+        Color::White
+    }
+}
+
+impl Color {
+    /// Returns a `Style` with the foreground color set to this color.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Red.normal();
+    /// println!("{}", style.paint("hi"));
+    /// ```
+    pub fn normal(self) -> Style {
+        Style {
+            foreground: Some(self),
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// bold property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Green.bold();
+    /// println!("{}", style.paint("hey"));
+    /// ```
+    pub fn bold(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_bold: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// dimmed property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Yellow.dimmed();
+    /// println!("{}", style.paint("sup"));
+    /// ```
+    pub fn dimmed(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_dimmed: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// italic property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Blue.italic();
+    /// println!("{}", style.paint("greetings"));
+    /// ```
+    pub fn italic(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_italic: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// underline property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Purple.underline();
+    /// println!("{}", style.paint("salutations"));
+    /// ```
+    pub fn underline(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_underline: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// blink property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Cyan.blink();
+    /// println!("{}", style.paint("wazzup"));
+    /// ```
+    pub fn blink(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_blink: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// reverse property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Black.reverse();
+    /// println!("{}", style.paint("aloha"));
+    /// ```
+    pub fn reverse(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_reverse: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// hidden property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::White.hidden();
+    /// println!("{}", style.paint("ahoy"));
+    /// ```
+    pub fn hidden(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_hidden: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// strikethrough property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Fixed(244).strikethrough();
+    /// println!("{}", style.paint("yo"));
+    /// ```
+    pub fn strikethrough(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_strikethrough: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// background color property set to the given color.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Rgb(31, 31, 31).on(Color::White);
+    /// println!("{}", style.paint("eyyyy"));
+    /// ```
+    pub fn on(self, background: Color) -> Style {
+        Style {
+            foreground: Some(self),
+            background: Some(background),
+            ..Style::default()
+        }
+    }
+}
+
+impl From<Color> for Style {
+    /// You can turn a `Color` into a `Style` with the foreground color set
+    /// with the `From` trait.
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color};
+    /// let green_foreground = Style::default().fg(Color::Green);
+    /// assert_eq!(green_foreground, Color::Green.normal());
+    /// assert_eq!(green_foreground, Color::Green.into());
+    /// assert_eq!(green_foreground, Style::from(Color::Green));
+    /// ```
+    fn from(color: Color) -> Style {
+        color.normal()
+    }
+}
+
+#[cfg(test)]
+#[cfg(feature = "derive_serde_style")]
+mod serde_json_tests {
+    use super::{Color, Style};
+
+    #[test]
+    fn color_serialization() {
+        let colors = &[
+            Color::Red,
+            Color::Blue,
+            Color::Rgb(123, 123, 123),
+            Color::Fixed(255),
+        ];
+
+        assert_eq!(
+            serde_json::to_string(&colors).unwrap(),
+            String::from("[\"Red\",\"Blue\",{\"Rgb\":[123,123,123]},{\"Fixed\":255}]")
+        );
+    }
+
+    #[test]
+    fn color_deserialization() {
+        let colors = [
+            Color::Red,
+            Color::Blue,
+            Color::Rgb(123, 123, 123),
+            Color::Fixed(255),
+        ];
+
+        for color in colors {
+            let serialized = serde_json::to_string(&color).unwrap();
+            let deserialized: Color = serde_json::from_str(&serialized).unwrap();
+
+            assert_eq!(color, deserialized);
+        }
+    }
+
+    #[test]
+    fn style_serialization() {
+        let style = Style::default();
+
+        assert_eq!(serde_json::to_string(&style).unwrap(), "{\"foreground\":null,\"background\":null,\"is_bold\":false,\"is_dimmed\":false,\"is_italic\":false,\"is_underline\":false,\"is_blink\":false,\"is_reverse\":false,\"is_hidden\":false,\"is_strikethrough\":false}".to_string());
+    }
+}

crates/nu-ansi-term/src/util.rs

@@ -0,0 +1,80 @@
+use crate::display::{AnsiString, AnsiStrings};
+use std::ops::Deref;
+
+/// Return a substring of the given ANSIStrings sequence, while keeping the formatting.
+pub fn sub_string<'a>(
+    start: usize,
+    len: usize,
+    strs: &AnsiStrings<'a>,
+) -> Vec<AnsiString<'static>> {
+    let mut vec = Vec::new();
+    let mut pos = start;
+    let mut len_rem = len;
+
+    for i in strs.0.iter() {
+        let fragment = i.deref();
+        let frag_len = fragment.len();
+        if pos >= frag_len {
+            pos -= frag_len;
+            continue;
+        }
+        if len_rem == 0 {
+            break;
+        }
+
+        let end = pos + len_rem;
+        let pos_end = if end >= frag_len { frag_len } else { end };
+
+        vec.push(i.style_ref().paint(String::from(&fragment[pos..pos_end])));
+
+        if end <= frag_len {
+            break;
+        }
+
+        len_rem -= pos_end - pos;
+        pos = 0;
+    }
+
+    vec
+}
+
+/// Return a concatenated copy of `strs` without the formatting, as an allocated `String`.
+pub fn unstyle(strs: &AnsiStrings) -> String {
+    let mut s = String::new();
+
+    for i in strs.0.iter() {
+        s += i.deref();
+    }
+
+    s
+}
+
+/// Return the unstyled length of ANSIStrings. This is equaivalent to `unstyle(strs).len()`.
+pub fn unstyled_len(strs: &AnsiStrings) -> usize {
+    let mut l = 0;
+    for i in strs.0.iter() {
+        l += i.deref().len();
+    }
+    l
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::Color::*;
+
+    #[test]
+    fn test() {
+        let l = [
+            Black.paint("first"),
+            Red.paint("-second"),
+            White.paint("-third"),
+        ];
+        let a = AnsiStrings(&l);
+        assert_eq!(unstyle(&a), "first-second-third");
+        assert_eq!(unstyled_len(&a), 18);
+
+        let l2 = [Black.paint("st"), Red.paint("-second"), White.paint("-t")];
+        assert_eq!(sub_string(3, 11, &a), l2);
+    }
+}

crates/nu-ansi-term/src/windows.rs

@@ -0,0 +1,62 @@
+/// Enables ANSI code support on Windows 10.
+///
+/// This uses Windows API calls to alter the properties of the console that
+/// the program is running in.
+///
+/// https://msdn.microsoft.com/en-us/library/windows/desktop/mt638032(v=vs.85).aspx
+///
+/// Returns a `Result` with the Windows error code if unsuccessful.
+#[cfg(windows)]
+pub fn enable_ansi_support() -> Result<(), u32> {
+    // ref: https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences#EXAMPLE_OF_ENABLING_VIRTUAL_TERMINAL_PROCESSING @@ https://archive.is/L7wRJ#76%
+
+    use std::ffi::OsStr;
+    use std::iter::once;
+    use std::os::windows::ffi::OsStrExt;
+    use std::ptr::null_mut;
+    use winapi::um::consoleapi::{GetConsoleMode, SetConsoleMode};
+    use winapi::um::errhandlingapi::GetLastError;
+    use winapi::um::fileapi::{CreateFileW, OPEN_EXISTING};
+    use winapi::um::handleapi::INVALID_HANDLE_VALUE;
+    use winapi::um::winnt::{FILE_SHARE_WRITE, GENERIC_READ, GENERIC_WRITE};
+
+    const ENABLE_VIRTUAL_TERMINAL_PROCESSING: u32 = 0x0004;
+
+    unsafe {
+        // ref: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
+        // Using `CreateFileW("CONOUT$", ...)` to retrieve the console handle works correctly even if STDOUT and/or STDERR are redirected
+        let console_out_name: Vec<u16> =
+            OsStr::new("CONOUT$").encode_wide().chain(once(0)).collect();
+        let console_handle = CreateFileW(
+            console_out_name.as_ptr(),
+            GENERIC_READ | GENERIC_WRITE,
+            FILE_SHARE_WRITE,
+            null_mut(),
+            OPEN_EXISTING,
+            0,
+            null_mut(),
+        );
+        if console_handle == INVALID_HANDLE_VALUE {
+            return Err(GetLastError());
+        }
+
+        // ref: https://docs.microsoft.com/en-us/windows/console/getconsolemode
+        let mut console_mode: u32 = 0;
+        if 0 == GetConsoleMode(console_handle, &mut console_mode) {
+            return Err(GetLastError());
+        }
+
+        // VT processing not already enabled?
+        if console_mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING == 0 {
+            // https://docs.microsoft.com/en-us/windows/console/setconsolemode
+            if 0 == SetConsoleMode(
+                console_handle,
+                console_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING,
+            ) {
+                return Err(GetLastError());
+            }
+        }
+    }
+
+    Ok(())
+}

crates/nu-ansi-term/src/write.rs

@@ -0,0 +1,37 @@
+use std::fmt;
+use std::io;
+
+pub trait AnyWrite {
+    type Wstr: ?Sized;
+    type Error;
+
+    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error>;
+
+    fn write_str(&mut self, s: &Self::Wstr) -> Result<(), Self::Error>;
+}
+
+impl<'a> AnyWrite for dyn fmt::Write + 'a {
+    type Wstr = str;
+    type Error = fmt::Error;
+
+    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error> {
+        fmt::Write::write_fmt(self, fmt)
+    }
+
+    fn write_str(&mut self, s: &Self::Wstr) -> Result<(), Self::Error> {
+        fmt::Write::write_str(self, s)
+    }
+}
+
+impl<'a> AnyWrite for dyn io::Write + 'a {
+    type Wstr = [u8];
+    type Error = io::Error;
+
+    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error> {
+        io::Write::write_fmt(self, fmt)
+    }
+
+    fn write_str(&mut self, s: &Self::Wstr) -> Result<(), Self::Error> {
+        io::Write::write_all(self, s)
+    }
+}

crates/nu-cli/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+authors = ["The Nu Project Contributors"]
+description = "CLI for nushell"
+edition = "2018"
+license = "MIT"
+name = "nu-cli"
+version = "0.40.0"
+build = "build.rs"
+
+[lib]
+doctest = false
+
+[dependencies]
+nu-completion = { version = "0.40.0", path="../nu-completion" }
+nu-command = { version = "0.40.0", path="../nu-command" }
+nu-data = { version = "0.40.0", path="../nu-data" }
+nu-engine = { version = "0.40.0", path="../nu-engine" }
+nu-errors = { version = "0.40.0", path="../nu-errors" }
+nu-parser = { version = "0.40.0", path="../nu-parser" }
+nu-protocol = { version = "0.40.0", path="../nu-protocol" }
+nu-source = { version = "0.40.0", path="../nu-source" }
+nu-stream = { version = "0.40.0", path="../nu-stream" }
+nu-ansi-term = { version = "0.40.0", path="../nu-ansi-term" }
+nu-path = { version = "0.40.0", path="../nu-path" }
+
+indexmap ="1.6.1"
+log = "0.4.14"
+pretty_env_logger = "0.4.0"
+strip-ansi-escapes = "0.1.0"
+rustyline = { version="9.0.0", optional=true }
+ctrlc = { version="3.1.7", optional=true }
+shadow-rs = { version="0.6", default-features=false, optional=true }
+serde = { version="1.0.123", features=["derive"] }
+serde_yaml = "0.8.16"
+lazy_static = "1.4.0"
+
+[build-dependencies]
+shadow-rs = "0.6"
+
+[features]
+default = ["shadow-rs"]
+rustyline-support = ["rustyline", "nu-engine/rustyline-support"]
+stable = []

crates/nu-cli/README.md

@@ -0,0 +1,4 @@
+# nu-cli
+
+This crate provides the fundamental needs when creating the Nushell interactive REPL. In it, you'll find features for interacting with the line editor (the piece which writes the prompt and takes input from the user), keybindings, handlers for the commandline arguments passed to the REPL as it starts up, and more.
+

crates/nu-cli/build.rs

@@ -0,0 +1,3 @@
+fn main() -> shadow_rs::SdResult<()> {
+    shadow_rs::new()
+}

crates/nu-cli/src/app.rs

@@ -0,0 +1,632 @@
+mod logger;
+mod options;
+mod options_parser;
+pub mod stopwatch;
+
+use self::stopwatch::Stopwatch;
+use lazy_static::lazy_static;
+use nu_command::{commands::NuSignature as Nu, utils::test_bins as binaries};
+use nu_engine::{get_full_help, EvaluationContext};
+use nu_errors::ShellError;
+use nu_protocol::hir::{Call, Expression, SpannedExpression, Synthetic};
+use nu_protocol::{Primitive, UntaggedValue};
+use nu_source::{Span, Tag};
+use nu_stream::InputStream;
+pub use options::{CliOptions, NuScript, Options};
+use options_parser::{NuParser, OptionsParser};
+use std::sync::Mutex;
+
+lazy_static! {
+    pub static ref STOPWATCH: Mutex<Stopwatch> = {
+        let mut sw = Stopwatch::default();
+        sw.start();
+        sw.stop();
+        Mutex::new(sw)
+    };
+}
+
+pub struct App {
+    parser: Box<dyn OptionsParser>,
+    pub options: Options,
+}
+
+impl App {
+    pub fn new(parser: Box<dyn OptionsParser>, options: Options) -> Self {
+        Self { parser, options }
+    }
+
+    pub fn run(args: &[String]) -> Result<(), ShellError> {
+        let nu = Box::new(NuParser::new());
+        let options = Options::default();
+        let ui = App::new(nu, options);
+
+        ui.main(args)
+    }
+
+    pub fn main(&self, argv: &[String]) -> Result<(), ShellError> {
+        if self.perf() {
+            // start the stopwatch running
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start();
+        }
+
+        let argv = quote_positionals(argv).join(" ");
+
+        if let Err(cause) = self.parse(&argv) {
+            self.parser
+                .context()
+                .host()
+                .lock()
+                .print_err(cause, &nu_source::Text::from(argv));
+            std::process::exit(1);
+        }
+
+        if self.help() {
+            let context = self.parser.context();
+            let stream = nu_stream::OutputStream::one(
+                UntaggedValue::string(get_full_help(&Nu, &context.scope))
+                    .into_value(nu_source::Tag::unknown()),
+            );
+
+            consume(context, stream)?;
+
+            if self.perf() {
+                // stop the stopwatch since we're exiting
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .stop();
+                eprintln!(
+                    "help {:?}",
+                    STOPWATCH
+                        .lock()
+                        .expect("unable to lock the stopwatch")
+                        .elapsed()
+                );
+            }
+
+            std::process::exit(0);
+        }
+
+        if self.version() {
+            let context = self.parser.context();
+
+            let stream = nu_command::commands::version(nu_engine::CommandArgs {
+                context: context.clone(),
+                call_info: nu_engine::UnevaluatedCallInfo {
+                    args: Call::new(
+                        Box::new(SpannedExpression::new(
+                            Expression::Synthetic(Synthetic::String("version".to_string())),
+                            Span::unknown(),
+                        )),
+                        Span::unknown(),
+                    ),
+                    name_tag: Tag::unknown(),
+                },
+                input: InputStream::empty(),
+            })?;
+
+            let stream = {
+                let command = context
+                    .get_command("pivot")
+                    .expect("could not find version command");
+
+                context.run_command(
+                    command,
+                    Tag::unknown(),
+                    Call::new(
+                        Box::new(SpannedExpression::new(
+                            Expression::Synthetic(Synthetic::String("pivot".to_string())),
+                            Span::unknown(),
+                        )),
+                        Span::unknown(),
+                    ),
+                    stream,
+                )?
+            };
+
+            consume(context, stream)?;
+
+            if self.perf() {
+                // stop the stopwatch since we're exiting
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .stop();
+                eprintln!(
+                    "version {:?}",
+                    STOPWATCH
+                        .lock()
+                        .expect("unable to lock the stopwatch")
+                        .elapsed()
+                );
+            }
+
+            std::process::exit(0);
+        }
+
+        if let Some(bin) = self.testbin() {
+            match bin.as_deref() {
+                Ok("echo_env") => binaries::echo_env(),
+                Ok("cococo") => binaries::cococo(),
+                Ok("meow") => binaries::meow(),
+                Ok("iecho") => binaries::iecho(),
+                Ok("fail") => binaries::fail(),
+                Ok("nonu") => binaries::nonu(),
+                Ok("chop") => binaries::chop(),
+                Ok("repeater") => binaries::repeater(),
+                _ => unreachable!(),
+            }
+
+            return Ok(());
+        }
+
+        let mut opts = CliOptions::new();
+        opts.config = self.config().map(std::ffi::OsString::from);
+        opts.stdin = self.takes_stdin();
+        opts.save_history = self.save_history();
+        opts.perf = self.perf();
+
+        use logger::{configure, debug_filters, logger, trace_filters};
+
+        logger(|builder| {
+            configure(self, builder)?;
+            trace_filters(self, builder)?;
+            debug_filters(self, builder)?;
+
+            Ok(())
+        })?;
+
+        if self.perf() {
+            // start a new split
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start()
+        }
+
+        if let Some(commands) = self.commands() {
+            let commands = commands?;
+            let script = NuScript::code(&commands)?;
+            opts.scripts = vec![script];
+            let context = crate::create_default_context(false)?;
+            return crate::run_script_file(context, opts);
+        }
+
+        if self.perf() {
+            // start a new spit
+            eprintln!(
+                "commands using -c at launch: {:?}",
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .elapsed_split()
+            );
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start();
+        }
+
+        if let Some(scripts) = self.scripts() {
+            let mut source_files = vec![];
+            for script in scripts {
+                let script_name = script?;
+                let path = std::ffi::OsString::from(&script_name);
+
+                match NuScript::source_file(path.as_os_str()) {
+                    Ok(file) => source_files.push(file),
+                    Err(_) => {
+                        eprintln!("File not found: {}", script_name);
+                        return Ok(());
+                    }
+                }
+            }
+
+            for file in source_files {
+                let mut opts = opts.clone();
+                opts.scripts = vec![file];
+
+                let context = crate::create_default_context(false)?;
+                crate::run_script_file(context, opts)?;
+            }
+
+            return Ok(());
+        }
+
+        if self.perf() {
+            // start a new split
+            eprintln!(
+                "script file(s) passed in: {:?}",
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .elapsed_split()
+            );
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start();
+        }
+
+        let context = crate::create_default_context(true)?;
+
+        if !self.skip_plugins() {
+            let _ = crate::register_plugins(&context);
+        }
+
+        if self.perf() {
+            // start a new split
+            eprintln!(
+                "plugins registered: {:?}",
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .elapsed_split()
+            );
+        }
+
+        #[cfg(feature = "rustyline-support")]
+        {
+            crate::cli(context, opts)?;
+        }
+
+        #[cfg(not(feature = "rustyline-support"))]
+        {
+            println!("Nushell needs the 'rustyline-support' feature for CLI support");
+        }
+
+        Ok(())
+    }
+
+    pub fn commands(&self) -> Option<Result<String, ShellError>> {
+        self.options.get("commands").map(|v| match v.value {
+            UntaggedValue::Error(err) => Err(err),
+            UntaggedValue::Primitive(Primitive::String(name)) => Ok(name),
+            _ => Err(ShellError::untagged_runtime_error("Unsupported option")),
+        })
+    }
+
+    pub fn perf(&self) -> bool {
+        self.options
+            .get("perf")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
+    pub fn help(&self) -> bool {
+        self.options
+            .get("help")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
+    pub fn version(&self) -> bool {
+        self.options
+            .get("version")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
+    pub fn scripts(&self) -> Option<Vec<Result<String, ShellError>>> {
+        self.options.get("args").map(|v| {
+            v.table_entries()
+                .map(|v| match &v.value {
+                    UntaggedValue::Error(err) => Err(err.clone()),
+                    UntaggedValue::Primitive(Primitive::FilePath(path)) => {
+                        Ok(path.display().to_string())
+                    }
+                    UntaggedValue::Primitive(Primitive::String(name)) => Ok(name.clone()),
+                    _ => Err(ShellError::untagged_runtime_error("Unsupported option")),
+                })
+                .collect()
+        })
+    }
+
+    pub fn takes_stdin(&self) -> bool {
+        self.options
+            .get("stdin")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
+    pub fn config(&self) -> Option<String> {
+        self.options
+            .get("config-file")
+            .map(|v| v.as_string().expect("not a string"))
+    }
+
+    pub fn develop(&self) -> Option<Vec<Result<String, ShellError>>> {
+        self.options.get("develop").map(|v| {
+            let mut values = vec![];
+
+            match v.value {
+                UntaggedValue::Error(err) => values.push(Err(err)),
+                UntaggedValue::Primitive(Primitive::String(filters)) => {
+                    values.extend(filters.split(',').map(|filter| Ok(filter.to_string())));
+                }
+                _ => values.push(Err(ShellError::untagged_runtime_error(
+                    "Unsupported option",
+                ))),
+            };
+
+            values
+        })
+    }
+
+    pub fn debug(&self) -> Option<Vec<Result<String, ShellError>>> {
+        self.options.get("debug").map(|v| {
+            let mut values = vec![];
+
+            match v.value {
+                UntaggedValue::Error(err) => values.push(Err(err)),
+                UntaggedValue::Primitive(Primitive::String(filters)) => {
+                    values.extend(filters.split(',').map(|filter| Ok(filter.to_string())));
+                }
+                _ => values.push(Err(ShellError::untagged_runtime_error(
+                    "Unsupported option",
+                ))),
+            };
+
+            values
+        })
+    }
+
+    pub fn loglevel(&self) -> Option<Result<String, ShellError>> {
+        self.options.get("loglevel").map(|v| match v.value {
+            UntaggedValue::Error(err) => Err(err),
+            UntaggedValue::Primitive(Primitive::String(name)) => Ok(name),
+            _ => Err(ShellError::untagged_runtime_error("Unsupported option")),
+        })
+    }
+
+    pub fn testbin(&self) -> Option<Result<String, ShellError>> {
+        self.options.get("testbin").map(|v| match v.value {
+            UntaggedValue::Error(err) => Err(err),
+            UntaggedValue::Primitive(Primitive::String(name)) => Ok(name),
+            _ => Err(ShellError::untagged_runtime_error("Unsupported option")),
+        })
+    }
+
+    pub fn skip_plugins(&self) -> bool {
+        self.options
+            .get("skip-plugins")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
+    pub fn save_history(&self) -> bool {
+        self.options
+            .get("no-history")
+            .map(|v| !matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(true)
+    }
+
+    pub fn parse(&self, args: &str) -> Result<(), ShellError> {
+        self.parser.parse(args).map(|options| {
+            self.options.swap(&options);
+        })
+    }
+}
+
+fn quote_positionals(parameters: &[String]) -> Vec<String> {
+    parameters
+        .iter()
+        .cloned()
+        .map(|arg| {
+            if arg.contains(' ') {
+                format!("\"{}\"", arg)
+            } else {
+                arg
+            }
+        })
+        .collect::<Vec<_>>()
+}
+
+fn consume(context: &EvaluationContext, stream: InputStream) -> Result<(), ShellError> {
+    let autoview_cmd = context
+        .get_command("autoview")
+        .expect("could not find autoview command");
+
+    let stream = context.run_command(
+        autoview_cmd,
+        Tag::unknown(),
+        Call::new(
+            Box::new(SpannedExpression::new(
+                Expression::Synthetic(Synthetic::String("autoview".to_string())),
+                Span::unknown(),
+            )),
+            Span::unknown(),
+        ),
+        stream,
+    )?;
+
+    for _ in stream {}
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn cli_app() -> App {
+        let parser = Box::new(NuParser::new());
+        let options = Options::default();
+
+        App::new(parser, options)
+    }
+
+    #[test]
+    fn default_options() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu")?;
+        assert!(!ui.version());
+        assert!(!ui.help());
+        assert!(!ui.takes_stdin());
+        assert!(ui.save_history());
+        assert!(!ui.skip_plugins());
+        assert_eq!(ui.config(), None);
+        assert_eq!(ui.loglevel(), None);
+        assert_eq!(ui.debug(), None);
+        assert_eq!(ui.develop(), None);
+        assert_eq!(ui.testbin(), None);
+        assert_eq!(ui.commands(), None);
+        assert_eq!(ui.scripts(), None);
+        Ok(())
+    }
+
+    #[test]
+    fn reports_errors_on_unsupported_flags() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        assert!(ui.parse("nu --coonfig-file /path/to/config.toml").is_err());
+        assert!(ui.config().is_none());
+        Ok(())
+    }
+
+    #[test]
+    fn configures_debug_trace_level_with_filters() -> Result<(), ShellError> {
+        let ui = cli_app();
+        ui.parse("nu --develop=cli,parser")?;
+        assert_eq!(ui.develop().unwrap()[0], Ok("cli".to_string()));
+        assert_eq!(ui.develop().unwrap()[1], Ok("parser".to_string()));
+        Ok(())
+    }
+
+    #[test]
+    fn configures_debug_level_with_filters() -> Result<(), ShellError> {
+        let ui = cli_app();
+        ui.parse("nu --debug=cli,run")?;
+        assert_eq!(ui.debug().unwrap()[0], Ok("cli".to_string()));
+        assert_eq!(ui.debug().unwrap()[1], Ok("run".to_string()));
+        Ok(())
+    }
+
+    #[test]
+    fn can_use_loglevels() -> Result<(), ShellError> {
+        for level in ["error", "warn", "info", "debug", "trace"] {
+            let ui = cli_app();
+            let args = format!("nu --loglevel={}", level);
+            ui.parse(&args)?;
+            assert_eq!(ui.loglevel().unwrap(), Ok(level.to_string()));
+
+            let ui = cli_app();
+            let args = format!("nu -l {}", level);
+            ui.parse(&args)?;
+            assert_eq!(ui.loglevel().unwrap(), Ok(level.to_string()));
+        }
+
+        let ui = cli_app();
+        ui.parse("nu --loglevel=nada")?;
+        assert_eq!(
+            ui.loglevel().unwrap(),
+            Err(ShellError::untagged_runtime_error("nada is not supported."))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn can_be_passed_nu_scripts() -> Result<(), ShellError> {
+        let ui = cli_app();
+        ui.parse("nu code.nu bootstrap.nu")?;
+        assert_eq!(ui.scripts().unwrap()[0], Ok("code.nu".into()));
+        assert_eq!(ui.scripts().unwrap()[1], Ok("bootstrap.nu".into()));
+        Ok(())
+    }
+
+    #[test]
+    fn can_use_test_binaries() -> Result<(), ShellError> {
+        for binarie_name in [
+            "echo_env", "cococo", "iecho", "fail", "nonu", "chop", "repeater", "meow",
+        ] {
+            let ui = cli_app();
+            let args = format!("nu --testbin={}", binarie_name);
+            ui.parse(&args)?;
+            assert_eq!(ui.testbin().unwrap(), Ok(binarie_name.to_string()));
+        }
+
+        let ui = cli_app();
+        ui.parse("nu --testbin=andres")?;
+        assert_eq!(
+            ui.testbin().unwrap(),
+            Err(ShellError::untagged_runtime_error(
+                "andres is not supported."
+            ))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn has_version() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --version")?;
+        assert!(ui.version());
+        Ok(())
+    }
+
+    #[test]
+    fn has_help() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --help")?;
+        assert!(ui.help());
+        Ok(())
+    }
+
+    #[test]
+    fn can_take_stdin() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --stdin")?;
+        assert!(ui.takes_stdin());
+        Ok(())
+    }
+
+    #[test]
+    fn can_opt_to_avoid_saving_history() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --no-history")?;
+        assert!(!ui.save_history());
+        Ok(())
+    }
+
+    #[test]
+    fn can_opt_to_skip_plugins() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --skip-plugins")?;
+        assert!(ui.skip_plugins());
+        Ok(())
+    }
+
+    #[test]
+    fn understands_commands_need_to_be_run() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu -c \"ls | get name\"")?;
+        assert_eq!(ui.commands().unwrap(), Ok(String::from("ls | get name")));
+
+        let ui = cli_app();
+
+        ui.parse("nu -c \"echo 'hola'\"")?;
+        assert_eq!(ui.commands().unwrap(), Ok(String::from("echo 'hola'")));
+        Ok(())
+    }
+
+    #[test]
+    fn knows_custom_configurations() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --config-file /path/to/config.toml")?;
+        assert_eq!(ui.config().unwrap(), String::from("/path/to/config.toml"));
+        Ok(())
+    }
+}

crates/nu-cli/src/app/logger.rs

@@ -0,0 +1,52 @@
+use super::App;
+use log::LevelFilter;
+use nu_errors::ShellError;
+use pretty_env_logger::env_logger::Builder;
+
+pub fn logger(f: impl FnOnce(&mut Builder) -> Result<(), ShellError>) -> Result<(), ShellError> {
+    let mut builder = pretty_env_logger::formatted_builder();
+    f(&mut builder)?;
+    let _ = builder.try_init();
+    Ok(())
+}
+
+pub fn configure(app: &App, logger: &mut Builder) -> Result<(), ShellError> {
+    if let Some(level) = app.loglevel() {
+        let level = match level.as_deref() {
+            Ok("error") => LevelFilter::Error,
+            Ok("warn") => LevelFilter::Warn,
+            Ok("info") => LevelFilter::Info,
+            Ok("debug") => LevelFilter::Debug,
+            Ok("trace") => LevelFilter::Trace,
+            Ok(_) | Err(_) => LevelFilter::Warn,
+        };
+
+        logger.filter_module("nu", level);
+    };
+
+    if let Ok(s) = std::env::var("RUST_LOG") {
+        logger.parse_filters(&s);
+    }
+
+    Ok(())
+}
+
+pub fn trace_filters(app: &App, logger: &mut Builder) -> Result<(), ShellError> {
+    if let Some(filters) = app.develop() {
+        filters.into_iter().filter_map(Result::ok).for_each(|name| {
+            logger.filter_module(&name, LevelFilter::Trace);
+        })
+    }
+
+    Ok(())
+}
+
+pub fn debug_filters(app: &App, logger: &mut Builder) -> Result<(), ShellError> {
+    if let Some(filters) = app.debug() {
+        filters.into_iter().filter_map(Result::ok).for_each(|name| {
+            logger.filter_module(&name, LevelFilter::Debug);
+        })
+    }
+
+    Ok(())
+}

crates/nu-cli/src/app/options.rs

@@ -0,0 +1,102 @@
+use indexmap::IndexMap;
+use nu_errors::ShellError;
+use nu_protocol::{UntaggedValue, Value};
+use std::cell::RefCell;
+use std::ffi::{OsStr, OsString};
+
+#[derive(Debug, Clone)]
+pub struct CliOptions {
+    pub config: Option<OsString>,
+    pub stdin: bool,
+    pub scripts: Vec<NuScript>,
+    pub save_history: bool,
+    pub perf: bool,
+}
+
+impl Default for CliOptions {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CliOptions {
+    pub fn new() -> Self {
+        Self {
+            config: None,
+            stdin: false,
+            scripts: vec![],
+            save_history: true,
+            perf: false,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Options {
+    inner: RefCell<IndexMap<String, Value>>,
+}
+
+impl Options {
+    pub fn default() -> Self {
+        Self {
+            inner: RefCell::new(IndexMap::default()),
+        }
+    }
+
+    pub fn get(&self, key: &str) -> Option<Value> {
+        self.inner.borrow().get(key).cloned()
+    }
+
+    pub fn put(&self, key: &str, value: Value) {
+        self.inner.borrow_mut().insert(key.into(), value);
+    }
+
+    pub fn shift(&self) {
+        if let Some(Value {
+            value: UntaggedValue::Table(ref mut args),
+            ..
+        }) = self.inner.borrow_mut().get_mut("args")
+        {
+            args.remove(0);
+        }
+    }
+
+    pub fn swap(&self, other: &Options) {
+        self.inner.swap(&other.inner);
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct NuScript {
+    pub filepath: Option<OsString>,
+    pub contents: String,
+}
+
+impl NuScript {
+    pub fn code(content: &str) -> Result<Self, ShellError> {
+        Ok(Self {
+            filepath: None,
+            contents: content.to_string(),
+        })
+    }
+
+    pub fn get_code(&self) -> &str {
+        &self.contents
+    }
+
+    pub fn source_file(path: &OsStr) -> Result<Self, ShellError> {
+        use std::fs::File;
+        use std::io::Read;
+
+        let path = path.to_os_string();
+        let mut file = File::open(&path)?;
+        let mut buffer = String::new();
+
+        file.read_to_string(&mut buffer)?;
+
+        Ok(Self {
+            filepath: Some(path),
+            contents: buffer,
+        })
+    }
+}

crates/nu-cli/src/app/options_parser.rs

@@ -0,0 +1,132 @@
+use super::Options;
+
+use nu_command::commands::{loglevels, testbins, NuSignature as Nu};
+use nu_command::commands::{Autoview, Pivot, Table, Version as NuVersion};
+use nu_engine::{whole_stream_command, EvaluationContext};
+use nu_errors::ShellError;
+use nu_protocol::hir::{ClassifiedCommand, InternalCommand, NamedValue};
+use nu_protocol::UntaggedValue;
+use nu_source::Tag;
+
+pub struct NuParser {
+    context: EvaluationContext,
+}
+
+pub trait OptionsParser {
+    fn parse(&self, input: &str) -> Result<Options, ShellError>;
+    fn context(&self) -> &EvaluationContext;
+}
+
+impl NuParser {
+    pub fn new() -> Self {
+        let context = EvaluationContext::basic();
+        context.add_commands(vec![
+            whole_stream_command(Nu {}),
+            whole_stream_command(NuVersion {}),
+            whole_stream_command(Autoview {}),
+            whole_stream_command(Pivot {}),
+            whole_stream_command(Table {}),
+        ]);
+
+        Self { context }
+    }
+}
+
+impl OptionsParser for NuParser {
+    fn context(&self) -> &EvaluationContext {
+        &self.context
+    }
+
+    fn parse(&self, input: &str) -> Result<Options, ShellError> {
+        let options = Options::default();
+        let (lite_result, _err) = nu_parser::lex(input, 0, nu_parser::NewlineMode::Normal);
+        let (lite_result, _err) = nu_parser::parse_block(lite_result);
+
+        let (parsed, err) = nu_parser::classify_block(&lite_result, &self.context.scope);
+
+        if let Some(reason) = err {
+            return Err(reason.into());
+        }
+
+        match parsed.block[0].pipelines[0].list[0] {
+            ClassifiedCommand::Internal(InternalCommand { ref args, .. }) => {
+                if let Some(ref params) = args.named {
+                    params.iter().for_each(|(k, v)| {
+                        let value = match v {
+                            NamedValue::AbsentSwitch => {
+                                Some(UntaggedValue::from(false).into_untagged_value())
+                            }
+                            NamedValue::PresentSwitch(span) => {
+                                Some(UntaggedValue::from(true).into_value(Tag::from(span)))
+                            }
+                            NamedValue::AbsentValue => None,
+                            NamedValue::Value(span, exprs) => {
+                                let value = nu_engine::evaluate_baseline_expr(exprs, &self.context)
+                                    .expect("value");
+                                Some(value.value.into_value(Tag::from(span)))
+                            }
+                        };
+
+                        let value = value.map(|v| match k.as_ref() {
+                            "testbin" => {
+                                if let Ok(name) = v.as_string() {
+                                    if testbins().iter().any(|n| name == *n) {
+                                        v
+                                    } else {
+                                        UntaggedValue::Error(ShellError::untagged_runtime_error(
+                                            format!("{} is not supported.", name),
+                                        ))
+                                        .into_value(v.tag)
+                                    }
+                                } else {
+                                    v
+                                }
+                            }
+                            "loglevel" => {
+                                if let Ok(name) = v.as_string() {
+                                    if loglevels().iter().any(|n| name == *n) {
+                                        v
+                                    } else {
+                                        UntaggedValue::Error(ShellError::untagged_runtime_error(
+                                            format!("{} is not supported.", name),
+                                        ))
+                                        .into_value(v.tag)
+                                    }
+                                } else {
+                                    v
+                                }
+                            }
+                            _ => v,
+                        });
+
+                        if let Some(value) = value {
+                            options.put(k, value);
+                        }
+                    });
+                }
+
+                let mut positional_args = vec![];
+
+                if let Some(positional) = &args.positional {
+                    for pos in positional {
+                        let result = nu_engine::evaluate_baseline_expr(pos, &self.context)?;
+                        positional_args.push(result);
+                    }
+                }
+
+                if !positional_args.is_empty() {
+                    options.put(
+                        "args",
+                        UntaggedValue::Table(positional_args).into_untagged_value(),
+                    );
+                }
+            }
+            ClassifiedCommand::Error(ref reason) => {
+                return Err(reason.clone().into());
+            }
+            _ => return Err(ShellError::untagged_runtime_error("unrecognized command")),
+        }
+
+        Ok(options)
+    }
+}

crates/nu-cli/src/app/stopwatch.rs

@@ -0,0 +1,118 @@
+#![allow(dead_code)]
+use std::default::Default;
+use std::fmt;
+use std::time::{Duration, Instant};
+
+#[derive(Clone, Copy)]
+pub struct Stopwatch {
+    /// The time the stopwatch was started last, if ever.
+    start_time: Option<Instant>,
+    /// The time the stopwatch was split last, if ever.
+    split_time: Option<Instant>,
+    /// The time elapsed while the stopwatch was running (between start() and stop()).
+    elapsed: Duration,
+}
+
+impl Default for Stopwatch {
+    fn default() -> Stopwatch {
+        Stopwatch {
+            start_time: None,
+            split_time: None,
+            elapsed: Duration::from_secs(0),
+        }
+    }
+}
+
+impl fmt::Display for Stopwatch {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        return write!(f, "{}ms", self.elapsed_ms());
+    }
+}
+
+impl Stopwatch {
+    /// Returns a new stopwatch.
+    pub fn new() -> Stopwatch {
+        let sw: Stopwatch = Default::default();
+        sw
+    }
+
+    /// Returns a new stopwatch which will immediately be started.
+    pub fn start_new() -> Stopwatch {
+        let mut sw = Stopwatch::new();
+        sw.start();
+        sw
+    }
+
+    /// Starts the stopwatch.
+    pub fn start(&mut self) {
+        self.start_time = Some(Instant::now());
+    }
+
+    /// Stops the stopwatch.
+    pub fn stop(&mut self) {
+        self.elapsed = self.elapsed();
+        self.start_time = None;
+        self.split_time = None;
+    }
+
+    /// Resets all counters and stops the stopwatch.
+    pub fn reset(&mut self) {
+        self.elapsed = Duration::from_secs(0);
+        self.start_time = None;
+        self.split_time = None;
+    }
+
+    /// Resets and starts the stopwatch again.
+    pub fn restart(&mut self) {
+        self.reset();
+        self.start();
+    }
+
+    /// Returns whether the stopwatch is running.
+    pub fn is_running(&self) -> bool {
+        self.start_time.is_some()
+    }
+
+    /// Returns the elapsed time since the start of the stopwatch.
+    pub fn elapsed(&self) -> Duration {
+        match self.start_time {
+            // stopwatch is running
+            Some(t1) => t1.elapsed() + self.elapsed,
+            // stopwatch is not running
+            None => self.elapsed,
+        }
+    }
+
+    /// Returns the elapsed time since the start of the stopwatch in milliseconds.
+    pub fn elapsed_ms(&self) -> i64 {
+        let dur = self.elapsed();
+        (dur.as_secs() * 1000 + dur.subsec_millis() as u64) as i64
+    }
+
+    /// Returns the elapsed time since last split or start/restart.
+    ///
+    /// If the stopwatch is in stopped state this will always return a zero Duration.
+    pub fn elapsed_split(&mut self) -> Duration {
+        match self.start_time {
+            // stopwatch is running
+            Some(start) => {
+                let res = match self.split_time {
+                    Some(split) => split.elapsed(),
+                    None => start.elapsed(),
+                };
+                self.split_time = Some(Instant::now());
+                res
+            }
+            // stopwatch is not running
+            None => Duration::from_secs(0),
+        }
+    }
+
+    /// Returns the elapsed time since last split or start/restart in milliseconds.
+    ///
+    /// If the stopwatch is in stopped state this will always return zero.
+    pub fn elapsed_split_ms(&mut self) -> i64 {
+        let dur = self.elapsed_split();
+        (dur.as_secs() * 1000 + dur.subsec_millis() as u64) as i64
+    }
+}

crates/nu-cli/src/cli.rs

@@ -0,0 +1,538 @@
+use crate::app::STOPWATCH;
+use crate::line_editor::configure_ctrl_c;
+use nu_ansi_term::Color;
+use nu_engine::{maybe_print_errors, run_block, script::run_script_standalone, EvaluationContext};
+
+#[allow(unused_imports)]
+pub(crate) use nu_engine::script::{process_script, LineResult};
+
+#[cfg(feature = "rustyline-support")]
+use crate::line_editor::{
+    configure_rustyline_editor, convert_rustyline_result_to_string,
+    default_rustyline_editor_configuration, nu_line_editor_helper,
+};
+
+#[allow(unused_imports)]
+use nu_data::config;
+use nu_source::{Tag, Text};
+use nu_stream::InputStream;
+#[allow(unused_imports)]
+use std::sync::atomic::Ordering;
+
+#[cfg(feature = "rustyline-support")]
+use rustyline::{self, error::ReadlineError};
+
+use nu_errors::ShellError;
+use nu_parser::ParserScope;
+use nu_path::expand_tilde;
+use nu_protocol::{hir::ExternalRedirection, ConfigPath, UntaggedValue, Value};
+
+use log::trace;
+use std::error::Error;
+use std::iter::Iterator;
+use std::path::PathBuf;
+
+// Name of environment variable where the prompt could be stored
+#[cfg(feature = "rustyline-support")]
+const PROMPT_COMMAND: &str = "PROMPT_COMMAND";
+
+pub fn search_paths() -> Vec<std::path::PathBuf> {
+    use std::env;
+    let mut search_paths = Vec::new();
+
+    // Automatically add path `nu` is in as a search path
+    if let Ok(exe_path) = env::current_exe() {
+        if let Some(exe_dir) = exe_path.parent() {
+            search_paths.push(exe_dir.to_path_buf());
+        }
+    }
+
+    if let Ok(config) = nu_data::config::config(Tag::unknown()) {
+        if let Some(Value {
+            value: UntaggedValue::Table(pipelines),
+            ..
+        }) = config.get("plugin_dirs")
+        {
+            for pipeline in pipelines {
+                if let Ok(plugin_dir) = pipeline.as_string() {
+                    search_paths.push(expand_tilde(plugin_dir));
+                }
+            }
+        }
+    }
+
+    search_paths
+}
+
+pub fn run_script_file(
+    context: EvaluationContext,
+    options: super::app::CliOptions,
+) -> Result<(), ShellError> {
+    if let Some(cfg) = options.config {
+        load_cfg_as_global_cfg(&context, PathBuf::from(cfg));
+    } else {
+        load_global_cfg(&context);
+    }
+
+    let _ = register_plugins(&context);
+    let _ = configure_ctrl_c(&context);
+
+    let script = options
+        .scripts
+        .get(0)
+        .ok_or_else(|| ShellError::unexpected("Nu source code not available"))?;
+
+    run_script_standalone(script.get_code().to_string(), options.stdin, &context, true)?;
+
+    Ok(())
+}
+
+#[cfg(feature = "rustyline-support")]
+fn default_prompt_string(cwd: &str) -> String {
+    format!(
+        "{}{}{}{}{}{}> ",
+        Color::Green.bold().prefix().to_string(),
+        cwd,
+        nu_ansi_term::ansi::RESET,
+        Color::Cyan.bold().prefix().to_string(),
+        current_branch(),
+        nu_ansi_term::ansi::RESET
+    )
+}
+
+#[cfg(feature = "rustyline-support")]
+fn evaluate_prompt_string(prompt_line: &str, context: &EvaluationContext, cwd: &str) -> String {
+    context.scope.enter_scope();
+    let (prompt_block, err) = nu_parser::parse(prompt_line, 0, &context.scope);
+
+    if err.is_some() {
+        context.scope.exit_scope();
+        default_prompt_string(cwd)
+    } else {
+        let run_result = run_block(
+            &prompt_block,
+            context,
+            InputStream::empty(),
+            ExternalRedirection::Stdout,
+        );
+        context.scope.exit_scope();
+
+        match run_result {
+            Ok(result) => match result.collect_string(Tag::unknown()) {
+                Ok(string_result) => {
+                    let errors = context.get_errors();
+                    maybe_print_errors(context, Text::from(prompt_line));
+                    context.clear_errors();
+
+                    if !errors.is_empty() {
+                        "> ".into()
+                    } else {
+                        string_result.item
+                    }
+                }
+                Err(e) => {
+                    context.host().lock().print_err(e, &Text::from(prompt_line));
+                    context.clear_errors();
+
+                    "> ".into()
+                }
+            },
+            Err(e) => {
+                context.host().lock().print_err(e, &Text::from(prompt_line));
+                context.clear_errors();
+
+                "> ".into()
+            }
+        }
+    }
+}
+
+#[cfg(feature = "rustyline-support")]
+pub fn cli(
+    context: EvaluationContext,
+    options: super::app::CliOptions,
+) -> Result<(), Box<dyn Error>> {
+    let _ = configure_ctrl_c(&context);
+
+    // start time for running startup scripts (this metric includes loading of the cfg, but w/e)
+    let startup_commands_start_time = std::time::Instant::now();
+
+    if let Some(cfg) = options.config {
+        load_cfg_as_global_cfg(&context, PathBuf::from(cfg));
+    } else {
+        load_global_cfg(&context);
+    }
+
+    // Store cmd duration in an env var
+    context.scope.add_env_var(
+        "CMD_DURATION_MS",
+        startup_commands_start_time
+            .elapsed()
+            .as_millis()
+            .to_string(),
+    );
+
+    if options.perf {
+        eprintln!(
+            "config loaded: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
+    //Configure rustyline
+    let mut rl = default_rustyline_editor_configuration();
+    let history_path = if let Some(cfg) = &context.configs().lock().global_config {
+        let _ = configure_rustyline_editor(&mut rl, cfg);
+        let helper = Some(nu_line_editor_helper(&context, cfg));
+        rl.set_helper(helper);
+        nu_data::config::path::history_path_or_default(cfg)
+    } else {
+        nu_data::config::path::default_history_path()
+    };
+
+    if options.perf {
+        eprintln!(
+            "rustyline configuration: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
+    // Don't load history if it's not necessary
+    if options.save_history {
+        let _ = rl.load_history(&history_path);
+    }
+
+    if options.perf {
+        eprintln!(
+            "history load: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
+    //set vars from cfg if present
+    let (skip_welcome_message, prompt) = if let Some(cfg) = &context.configs().lock().global_config
+    {
+        (
+            cfg.var("skip_welcome_message")
+                .map(|x| x.is_true())
+                .unwrap_or(false),
+            cfg.var("prompt"),
+        )
+    } else {
+        (false, None)
+    };
+
+    if options.perf {
+        eprintln!(
+            "load custom prompt: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
+    //Check whether dir we start in contains local cfg file and if so load it.
+    load_local_cfg_if_present(&context);
+
+    // Give ourselves a scope to work in
+    context.scope.enter_scope();
+
+    let mut session_text = String::new();
+    let mut line_start: usize = 0;
+
+    if !skip_welcome_message {
+        println!(
+            "Welcome to Nushell {} (type 'help' for more info)",
+            nu_command::commands::core_version()
+        );
+    }
+
+    #[cfg(windows)]
+    {
+        let _ = nu_ansi_term::enable_ansi_support();
+    }
+
+    let mut ctrlcbreak = false;
+
+    if options.perf {
+        eprintln!(
+            "timing stopped. starting run loop: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .stop();
+    }
+
+    loop {
+        if context.ctrl_c().load(Ordering::SeqCst) {
+            context.ctrl_c().store(false, Ordering::SeqCst);
+            continue;
+        }
+
+        let cwd = context.shell_manager().path();
+
+        // Check if the PROMPT_COMMAND env variable is set. This env variable
+        // contains nu code that is used to overwrite the prompt
+        let colored_prompt = match context.scope.get_env(PROMPT_COMMAND) {
+            Some(env_prompt) => evaluate_prompt_string(&env_prompt, &context, &cwd),
+            None => {
+                if let Some(prompt) = &prompt {
+                    let prompt_line = prompt.as_string()?;
+                    evaluate_prompt_string(&prompt_line, &context, &cwd)
+                } else {
+                    default_prompt_string(&cwd)
+                }
+            }
+        };
+
+        let prompt = {
+            if let Ok(bytes) = strip_ansi_escapes::strip(&colored_prompt) {
+                String::from_utf8_lossy(&bytes).to_string()
+            } else {
+                "> ".to_string()
+            }
+        };
+
+        if let Some(helper) = rl.helper_mut() {
+            helper.colored_prompt = colored_prompt;
+        }
+        let mut initial_command = Some(String::new());
+        let mut readline = Err(ReadlineError::Eof);
+        while let Some(ref cmd) = initial_command {
+            readline = rl.readline_with_initial(&prompt, (cmd, ""));
+            initial_command = None;
+        }
+
+        if let Ok(line) = &readline {
+            line_start = session_text.len();
+            session_text.push_str(line);
+            session_text.push('\n');
+        }
+
+        // start time for command duration
+        let cmd_start_time = std::time::Instant::now();
+
+        let line = match convert_rustyline_result_to_string(readline) {
+            LineResult::Success(_) => process_script(
+                &session_text[line_start..],
+                &context,
+                false,
+                line_start,
+                true,
+            ),
+            x => x,
+        };
+
+        // Store cmd duration in an env var
+        context.scope.add_env_var(
+            "CMD_DURATION_MS",
+            cmd_start_time.elapsed().as_millis().to_string(),
+        );
+
+        match line {
+            LineResult::Success(line) => {
+                if options.save_history && !line.trim().is_empty() {
+                    rl.add_history_entry(&line);
+                    let _ = rl.append_history(&history_path);
+                }
+                maybe_print_errors(&context, Text::from(session_text.clone()));
+            }
+
+            LineResult::ClearHistory => {
+                if options.save_history {
+                    rl.clear_history();
+                    std::fs::remove_file(&history_path)?;
+                }
+            }
+
+            LineResult::Error(line, err) => {
+                if options.save_history && !line.trim().is_empty() {
+                    rl.add_history_entry(&line);
+                    let _ = rl.append_history(&history_path);
+                }
+
+                context
+                    .host()
+                    .lock()
+                    .print_err(err, &Text::from(session_text.clone()));
+
+                // I am not so sure, we don't need maybe_print_errors here (as we printed an err
+                // above), because maybe_print_errors also clears the errors.
+                // TODO Analyze where above err comes from, and whether we need to clear
+                // context.errors here
+                // Or just be consistent and return errors always in context.errors...
+                maybe_print_errors(&context, Text::from(session_text.clone()));
+            }
+
+            LineResult::CtrlC => {
+                let config_ctrlc_exit = context
+                    .configs()
+                    .lock()
+                    .global_config
+                    .as_ref()
+                    .and_then(|cfg| cfg.var("ctrlc_exit"))
+                    .map(|ctrl_c| ctrl_c.is_true())
+                    .unwrap_or(false); // default behavior is to allow CTRL-C spamming similar to other shells
+
+                if !config_ctrlc_exit {
+                    continue;
+                }
+
+                if ctrlcbreak {
+                    if options.save_history {
+                        let _ = rl.append_history(&history_path);
+                    }
+                    std::process::exit(0);
+                } else {
+                    context.with_host(|host| host.stdout("CTRL-C pressed (again to quit)"));
+                    ctrlcbreak = true;
+                    continue;
+                }
+            }
+
+            LineResult::CtrlD => {
+                context.shell_manager().remove_at_current();
+                if context.shell_manager().is_empty() {
+                    break;
+                }
+            }
+
+            LineResult::Break => {
+                break;
+            }
+        }
+        ctrlcbreak = false;
+    }
+
+    // we are ok if we can not save history
+    if options.save_history {
+        let _ = rl.append_history(&history_path);
+    }
+
+    Ok(())
+}
+
+#[cfg(feature = "rustyline-support")]
+pub fn load_local_cfg_if_present(context: &EvaluationContext) {
+    trace!("Loading local cfg if present");
+    match config::loadable_cfg_exists_in_dir(PathBuf::from(context.shell_manager().path())) {
+        Ok(Some(cfg_path)) => {
+            if let Err(err) = context.load_config(&ConfigPath::Local(cfg_path)) {
+                context.host().lock().print_err(err, &Text::from(""))
+            }
+        }
+        Err(e) => {
+            //Report error while checking for local cfg file
+            context.host().lock().print_err(e, &Text::from(""))
+        }
+        Ok(None) => {
+            //No local cfg file present in start dir
+        }
+    }
+}
+
+fn load_cfg_as_global_cfg(context: &EvaluationContext, path: PathBuf) {
+    if let Err(err) = context.load_config(&ConfigPath::Global(path)) {
+        context.host().lock().print_err(err, &Text::from(""));
+    }
+}
+
+pub fn load_global_cfg(context: &EvaluationContext) {
+    match config::default_path() {
+        Ok(path) => {
+            load_cfg_as_global_cfg(context, path);
+        }
+        Err(e) => {
+            context.host().lock().print_err(e, &Text::from(""));
+        }
+    }
+}
+
+pub fn register_plugins(context: &EvaluationContext) -> Result<(), ShellError> {
+    if let Ok(plugins) = nu_engine::plugin::build_plugin::scan(search_paths()) {
+        context.add_commands(
+            plugins
+                .into_iter()
+                .filter(|p| !context.is_command_registered(p.name()))
+                .collect(),
+        );
+    }
+
+    Ok(())
+}
+
+pub fn parse_and_eval(line: &str, ctx: &EvaluationContext) -> Result<String, ShellError> {
+    // FIXME: do we still need this?
+    let line = if let Some(s) = line.strip_suffix('\n') {
+        s
+    } else {
+        line
+    };
+
+    // TODO ensure the command whose examples we're testing is actually in the pipeline
+    ctx.scope.enter_scope();
+    let (classified_block, err) = nu_parser::parse(line, 0, &ctx.scope);
+    if let Some(err) = err {
+        ctx.scope.exit_scope();
+        return Err(err.into());
+    }
+
+    let input_stream = InputStream::empty();
+
+    let result = run_block(
+        &classified_block,
+        ctx,
+        input_stream,
+        ExternalRedirection::Stdout,
+    );
+    ctx.scope.exit_scope();
+
+    result?.collect_string(Tag::unknown()).map(|x| x.item)
+}
+
+#[allow(dead_code)]
+fn current_branch() -> String {
+    #[cfg(feature = "shadow-rs")]
+    {
+        Some(shadow_rs::branch())
+            .map(|x| x.trim().to_string())
+            .filter(|x| !x.is_empty())
+            .map(|x| format!("({})", x))
+            .unwrap_or_default()
+    }
+    #[cfg(not(feature = "shadow-rs"))]
+    {
+        "".to_string()
+    }
+}

crates/nu-cli/src/keybinding.rs

@@ -0,0 +1,473 @@
+use rustyline::{KeyCode as RustyKeyCode, Modifiers};
+use serde::{Deserialize, Serialize};
+
+pub fn convert_keyevent(key_event: KeyCode, modifiers: Option<Modifiers>) -> rustyline::KeyEvent {
+    match key_event {
+        KeyCode::UnknownEscSeq => convert_to_rl_keyevent(RustyKeyCode::UnknownEscSeq, modifiers),
+        KeyCode::Backspace => convert_to_rl_keyevent(RustyKeyCode::Backspace, modifiers),
+        KeyCode::BackTab => convert_to_rl_keyevent(RustyKeyCode::BackTab, modifiers),
+        KeyCode::BracketedPasteStart => {
+            convert_to_rl_keyevent(RustyKeyCode::BracketedPasteStart, modifiers)
+        }
+        KeyCode::BracketedPasteEnd => {
+            convert_to_rl_keyevent(RustyKeyCode::BracketedPasteEnd, modifiers)
+        }
+        KeyCode::Char(c) => convert_to_rl_keyevent(RustyKeyCode::Char(c), modifiers),
+        KeyCode::Delete => convert_to_rl_keyevent(RustyKeyCode::Delete, modifiers),
+        KeyCode::Down => convert_to_rl_keyevent(RustyKeyCode::Down, modifiers),
+        KeyCode::End => convert_to_rl_keyevent(RustyKeyCode::End, modifiers),
+        KeyCode::Enter => convert_to_rl_keyevent(RustyKeyCode::Enter, modifiers),
+        KeyCode::Esc => convert_to_rl_keyevent(RustyKeyCode::Esc, modifiers),
+        KeyCode::F(u) => convert_to_rl_keyevent(RustyKeyCode::F(u), modifiers),
+        KeyCode::Home => convert_to_rl_keyevent(RustyKeyCode::Home, modifiers),
+        KeyCode::Insert => convert_to_rl_keyevent(RustyKeyCode::Insert, modifiers),
+        KeyCode::Left => convert_to_rl_keyevent(RustyKeyCode::Left, modifiers),
+        KeyCode::Null => convert_to_rl_keyevent(RustyKeyCode::Null, modifiers),
+        KeyCode::PageDown => convert_to_rl_keyevent(RustyKeyCode::PageDown, modifiers),
+        KeyCode::PageUp => convert_to_rl_keyevent(RustyKeyCode::PageUp, modifiers),
+        KeyCode::Right => convert_to_rl_keyevent(RustyKeyCode::Right, modifiers),
+        KeyCode::Tab => convert_to_rl_keyevent(RustyKeyCode::Tab, modifiers),
+        KeyCode::Up => convert_to_rl_keyevent(RustyKeyCode::Up, modifiers),
+    }
+}
+
+fn convert_to_rl_keyevent(
+    key_code: RustyKeyCode,
+    modifier: Option<Modifiers>,
+) -> rustyline::KeyEvent {
+    rustyline::KeyEvent {
+        0: key_code,
+        1: modifier.unwrap_or(Modifiers::NONE),
+    }
+}
+
+fn convert_word(word: Word) -> rustyline::Word {
+    match word {
+        Word::Big => rustyline::Word::Big,
+        Word::Emacs => rustyline::Word::Emacs,
+        Word::Vi => rustyline::Word::Vi,
+    }
+}
+
+fn convert_at(at: At) -> rustyline::At {
+    match at {
+        At::AfterEnd => rustyline::At::AfterEnd,
+        At::BeforeEnd => rustyline::At::BeforeEnd,
+        At::Start => rustyline::At::Start,
+    }
+}
+
+fn convert_char_search(search: CharSearch) -> rustyline::CharSearch {
+    match search {
+        CharSearch::Backward(c) => rustyline::CharSearch::Backward(c),
+        CharSearch::BackwardAfter(c) => rustyline::CharSearch::BackwardAfter(c),
+        CharSearch::Forward(c) => rustyline::CharSearch::Forward(c),
+        CharSearch::ForwardBefore(c) => rustyline::CharSearch::ForwardBefore(c),
+    }
+}
+
+fn convert_movement(movement: Movement) -> rustyline::Movement {
+    match movement {
+        Movement::BackwardChar(u) => rustyline::Movement::BackwardChar(u),
+        Movement::BackwardWord { repeat, word } => {
+            rustyline::Movement::BackwardWord(repeat, convert_word(word))
+        }
+        Movement::BeginningOfBuffer => rustyline::Movement::BeginningOfBuffer,
+        Movement::BeginningOfLine => rustyline::Movement::BeginningOfLine,
+        Movement::EndOfBuffer => rustyline::Movement::EndOfBuffer,
+        Movement::EndOfLine => rustyline::Movement::EndOfLine,
+        Movement::ForwardChar(u) => rustyline::Movement::ForwardChar(u),
+        Movement::ForwardWord { repeat, at, word } => {
+            rustyline::Movement::ForwardWord(repeat, convert_at(at), convert_word(word))
+        }
+        Movement::LineDown(u) => rustyline::Movement::LineDown(u),
+        Movement::LineUp(u) => rustyline::Movement::LineUp(u),
+        Movement::ViCharSearch { repeat, search } => {
+            rustyline::Movement::ViCharSearch(repeat, convert_char_search(search))
+        }
+        Movement::ViFirstPrint => rustyline::Movement::ViFirstPrint,
+        Movement::WholeBuffer => rustyline::Movement::WholeBuffer,
+        Movement::WholeLine => rustyline::Movement::WholeLine,
+    }
+}
+
+fn convert_anchor(anchor: Anchor) -> rustyline::Anchor {
+    match anchor {
+        Anchor::After => rustyline::Anchor::After,
+        Anchor::Before => rustyline::Anchor::Before,
+    }
+}
+
+fn convert_cmd(cmd: Cmd) -> rustyline::Cmd {
+    match cmd {
+        Cmd::Abort => rustyline::Cmd::Abort,
+        Cmd::AcceptLine => rustyline::Cmd::AcceptLine,
+        Cmd::AcceptOrInsertLine => rustyline::Cmd::AcceptOrInsertLine {
+            accept_in_the_middle: false,
+        },
+        Cmd::BeginningOfHistory => rustyline::Cmd::BeginningOfHistory,
+        Cmd::CapitalizeWord => rustyline::Cmd::CapitalizeWord,
+        Cmd::ClearScreen => rustyline::Cmd::ClearScreen,
+        Cmd::Complete => rustyline::Cmd::Complete,
+        Cmd::CompleteBackward => rustyline::Cmd::CompleteBackward,
+        Cmd::CompleteHint => rustyline::Cmd::CompleteHint,
+        Cmd::Dedent(movement) => rustyline::Cmd::Dedent(convert_movement(movement)),
+        Cmd::DowncaseWord => rustyline::Cmd::DowncaseWord,
+        Cmd::EndOfFile => rustyline::Cmd::EndOfFile,
+        Cmd::EndOfHistory => rustyline::Cmd::EndOfHistory,
+        Cmd::ForwardSearchHistory => rustyline::Cmd::ForwardSearchHistory,
+        Cmd::HistorySearchBackward => rustyline::Cmd::HistorySearchBackward,
+        Cmd::HistorySearchForward => rustyline::Cmd::HistorySearchForward,
+        Cmd::Indent(movement) => rustyline::Cmd::Indent(convert_movement(movement)),
+        Cmd::Insert { repeat, string } => rustyline::Cmd::Insert(repeat, string),
+        Cmd::Interrupt => rustyline::Cmd::Interrupt,
+        Cmd::Kill(movement) => rustyline::Cmd::Kill(convert_movement(movement)),
+        Cmd::LineDownOrNextHistory(u) => rustyline::Cmd::LineDownOrNextHistory(u),
+        Cmd::LineUpOrPreviousHistory(u) => rustyline::Cmd::LineUpOrPreviousHistory(u),
+        Cmd::Move(movement) => rustyline::Cmd::Move(convert_movement(movement)),
+        Cmd::NextHistory => rustyline::Cmd::NextHistory,
+        Cmd::Newline => rustyline::Cmd::Newline,
+        Cmd::Noop => rustyline::Cmd::Noop,
+        Cmd::Overwrite(c) => rustyline::Cmd::Overwrite(c),
+        #[cfg(windows)]
+        Cmd::PasteFromClipboard => rustyline::Cmd::PasteFromClipboard,
+        Cmd::PreviousHistory => rustyline::Cmd::PreviousHistory,
+        Cmd::QuotedInsert => rustyline::Cmd::QuotedInsert,
+        Cmd::Replace {
+            movement,
+            replacement,
+        } => rustyline::Cmd::Replace(convert_movement(movement), replacement),
+        Cmd::ReplaceChar { repeat, ch } => rustyline::Cmd::ReplaceChar(repeat, ch),
+        Cmd::ReverseSearchHistory => rustyline::Cmd::ReverseSearchHistory,
+        Cmd::SelfInsert { repeat, ch } => rustyline::Cmd::SelfInsert(repeat, ch),
+        Cmd::Suspend => rustyline::Cmd::Suspend,
+        Cmd::TransposeChars => rustyline::Cmd::TransposeChars,
+        Cmd::TransposeWords(u) => rustyline::Cmd::TransposeWords(u),
+        Cmd::Undo(u) => rustyline::Cmd::Undo(u),
+        Cmd::Unknown => rustyline::Cmd::Unknown,
+        Cmd::UpcaseWord => rustyline::Cmd::UpcaseWord,
+        Cmd::ViYankTo(movement) => rustyline::Cmd::ViYankTo(convert_movement(movement)),
+        Cmd::Yank { repeat, anchor } => rustyline::Cmd::Yank(repeat, convert_anchor(anchor)),
+        Cmd::YankPop => rustyline::Cmd::YankPop,
+    }
+}
+
+fn convert_keybinding(keybinding: Keybinding) -> (rustyline::KeyEvent, rustyline::Cmd) {
+    let rusty_modifiers = match keybinding.modifiers {
+        Some(mods) => match mods {
+            NuModifiers::Ctrl => Some(Modifiers::CTRL),
+            NuModifiers::Alt => Some(Modifiers::ALT),
+            NuModifiers::Shift => Some(Modifiers::SHIFT),
+            NuModifiers::None => Some(Modifiers::NONE),
+            NuModifiers::CtrlShift => Some(Modifiers::CTRL_SHIFT),
+            NuModifiers::AltShift => Some(Modifiers::ALT_SHIFT),
+            NuModifiers::CtrlAlt => Some(Modifiers::CTRL_ALT),
+            NuModifiers::CtrlAltShift => Some(Modifiers::CTRL_ALT_SHIFT),
+            // _ => None,
+        },
+        None => None,
+    };
+    (
+        convert_keyevent(keybinding.key, rusty_modifiers),
+        convert_cmd(keybinding.binding),
+    )
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum KeyCode {
+    /// Unsupported escape sequence (on unix platform)
+    UnknownEscSeq,
+    /// ⌫ or `KeyEvent::Ctrl('H')`
+    Backspace,
+    /// ⇤ (usually Shift-Tab)
+    BackTab,
+    /// Paste (on unix platform)
+    BracketedPasteStart,
+    /// Paste (on unix platform)
+    BracketedPasteEnd,
+    /// Single char
+    Char(char),
+    /// ⌦
+    Delete,
+    /// ↓ arrow key
+    Down,
+    /// ⇲
+    End,
+    /// ↵ or `KeyEvent::Ctrl('M')`
+    Enter,
+    /// Escape or `KeyEvent::Ctrl('[')`
+    Esc,
+    /// Function key
+    F(u8),
+    /// ⇱
+    Home,
+    /// Insert key
+    Insert,
+    /// ← arrow key
+    Left,
+    // /// `KeyEvent::Char('\0')`
+    Null,
+    /// ⇟
+    PageDown,
+    /// ⇞
+    PageUp,
+    /// → arrow key
+    Right,
+    /// ⇥ or `KeyEvent::Ctrl('I')`
+    Tab,
+    /// ↑ arrow key
+    Up,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum Cmd {
+    /// abort
+    Abort, // Miscellaneous Command
+    /// accept-line
+    AcceptLine,
+    /// beginning-of-history
+    BeginningOfHistory,
+    /// capitalize-word
+    CapitalizeWord,
+    /// clear-screen
+    ClearScreen,
+    /// complete
+    Complete,
+    /// complete-backward
+    CompleteBackward,
+    /// complete-hint
+    CompleteHint,
+    /// Dedent current line
+    Dedent(Movement),
+    /// downcase-word
+    DowncaseWord,
+    /// vi-eof-maybe
+    EndOfFile,
+    /// end-of-history
+    EndOfHistory,
+    /// forward-search-history
+    ForwardSearchHistory,
+    /// history-search-backward
+    HistorySearchBackward,
+    /// history-search-forward
+    HistorySearchForward,
+    /// Indent current line
+    Indent(Movement),
+    /// Insert text
+    Insert { repeat: RepeatCount, string: String },
+    /// Interrupt signal (Ctrl-C)
+    Interrupt,
+    /// backward-delete-char, backward-kill-line, backward-kill-word
+    /// delete-char, kill-line, kill-word, unix-line-discard, unix-word-rubout,
+    /// vi-delete, vi-delete-to, vi-rubout
+    Kill(Movement),
+    /// backward-char, backward-word, beginning-of-line, end-of-line,
+    /// forward-char, forward-word, vi-char-search, vi-end-word, vi-next-word,
+    /// vi-prev-word
+    Move(Movement),
+    /// Inserts a newline
+    Newline,
+    /// next-history
+    NextHistory,
+    /// No action
+    Noop,
+    /// vi-replace
+    Overwrite(char),
+    /// Paste from the clipboard
+    #[cfg(windows)]
+    PasteFromClipboard,
+    /// previous-history
+    PreviousHistory,
+    /// quoted-insert
+    QuotedInsert,
+    /// vi-change-char
+    ReplaceChar { repeat: RepeatCount, ch: char },
+    /// vi-change-to, vi-substitute
+    Replace {
+        movement: Movement,
+        replacement: Option<String>,
+    },
+    /// reverse-search-history
+    ReverseSearchHistory,
+    /// self-insert
+    SelfInsert { repeat: RepeatCount, ch: char },
+    /// Suspend signal (Ctrl-Z on unix platform)
+    Suspend,
+    /// transpose-chars
+    TransposeChars,
+    /// transpose-words
+    TransposeWords(RepeatCount),
+    /// undo
+    Undo(RepeatCount),
+    /// Unsupported / unexpected
+    Unknown,
+    /// upcase-word
+    UpcaseWord,
+    /// vi-yank-to
+    ViYankTo(Movement),
+    /// yank, vi-put
+    Yank { repeat: RepeatCount, anchor: Anchor },
+    /// yank-pop
+    YankPop,
+    /// moves cursor to the line above or switches to prev history entry if
+    /// the cursor is already on the first line
+    LineUpOrPreviousHistory(RepeatCount),
+    /// moves cursor to the line below or switches to next history entry if
+    /// the cursor is already on the last line
+    LineDownOrNextHistory(RepeatCount),
+    /// accepts the line when cursor is at the end of the text (non including
+    /// trailing whitespace), inserts newline character otherwise
+    AcceptOrInsertLine,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum Movement {
+    /// Whole current line (not really a movement but a range)
+    WholeLine,
+    /// beginning-of-line
+    BeginningOfLine,
+    /// end-of-line
+    EndOfLine,
+    /// backward-word, vi-prev-word
+    BackwardWord { repeat: RepeatCount, word: Word }, // Backward until start of word
+    /// forward-word, vi-end-word, vi-next-word
+    ForwardWord {
+        repeat: RepeatCount,
+        at: At,
+        word: Word,
+    }, // Forward until start/end of word
+    /// vi-char-search
+    ViCharSearch {
+        repeat: RepeatCount,
+        search: CharSearch,
+    },
+    /// vi-first-print
+    ViFirstPrint,
+    /// backward-char
+    BackwardChar(RepeatCount),
+    /// forward-char
+    ForwardChar(RepeatCount),
+    /// move to the same column on the previous line
+    LineUp(RepeatCount),
+    /// move to the same column on the next line
+    LineDown(RepeatCount),
+    /// Whole user input (not really a movement but a range)
+    WholeBuffer,
+    /// beginning-of-buffer
+    BeginningOfBuffer,
+    /// end-of-buffer
+    EndOfBuffer,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+enum InputMode {
+    /// Vi Command/Alternate
+    Command,
+    /// Insert/Input mode
+    Insert,
+    /// Overwrite mode
+    Replace,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum Word {
+    /// non-blanks characters
+    Big,
+    /// alphanumeric characters
+    Emacs,
+    /// alphanumeric (and '_') characters
+    Vi,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum At {
+    /// Start of word.
+    Start,
+    /// Before end of word.
+    BeforeEnd,
+    /// After end of word.
+    AfterEnd,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum Anchor {
+    /// After cursor
+    After,
+    /// Before cursor
+    Before,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum CharSearch {
+    /// Forward search
+    Forward(char),
+    /// Forward search until
+    ForwardBefore(char),
+    /// Backward search
+    Backward(char),
+    /// Backward search until
+    BackwardAfter(char),
+}
+
+/// The set of modifier keys that were triggered along with a key press.
+#[derive(Debug, Serialize, Deserialize)]
+#[allow(non_camel_case_types)]
+pub enum NuModifiers {
+    /// Control modifier
+    #[serde(alias = "CTRL")]
+    Ctrl = 8,
+    /// Escape or Alt modifier
+    #[serde(alias = "ALT")]
+    Alt = 4,
+    /// Shift modifier
+    #[serde(alias = "SHIFT")]
+    Shift = 2,
+    /// No modifier
+    #[serde(alias = "NONE")]
+    None = 0,
+    /// Ctrl + Shift
+    #[serde(alias = "CTRL_SHIFT")]
+    CtrlShift = 10,
+    /// Alt + Shift
+    #[serde(alias = "ALT_SHIFT")]
+    AltShift = 6,
+    /// Ctrl + Alt
+    #[serde(alias = "CTRL_ALT")]
+    CtrlAlt = 12,
+    /// Ctrl + Alt + Shift
+    #[serde(alias = "CTRL_ALT_SHIFT")]
+    CtrlAltShift = 14,
+}
+
+/// The number of times one command should be repeated.
+pub type RepeatCount = usize;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Keybinding {
+    key: KeyCode,
+    modifiers: Option<NuModifiers>,
+    binding: Cmd,
+}
+
+type Keybindings = Vec<Keybinding>;
+
+pub(crate) fn load_keybindings(
+    rl: &mut rustyline::Editor<crate::shell::Helper>,
+) -> Result<(), nu_errors::ShellError> {
+    let filename = nu_data::keybinding::keybinding_path()?;
+    let contents = std::fs::read_to_string(filename);
+
+    // Silently fail if there is no file there
+    if let Ok(contents) = contents {
+        let keybindings: Keybindings = serde_yaml::from_str(&contents)?;
+        // eprintln!("{:#?}", keybindings);
+        for keybinding in keybindings {
+            let (k, b) = convert_keybinding(keybinding);
+            // eprintln!("{:?} {:?}", k, b);
+
+            rl.bind_sequence(k, b);
+        }
+    }
+
+    Ok(())
+}

crates/nu-cli/src/lib.rs

@@ -0,0 +1,15 @@
+pub mod app;
+mod cli;
+#[cfg(feature = "rustyline-support")]
+mod keybinding;
+mod line_editor;
+#[cfg(feature = "rustyline-support")]
+mod shell;
+
+#[cfg(feature = "rustyline-support")]
+pub use crate::cli::cli;
+
+pub use crate::app::App;
+pub use crate::cli::{parse_and_eval, register_plugins, run_script_file};
+
+pub use nu_command::create_default_context;

crates/nu-cli/src/line_editor.rs

@@ -0,0 +1,276 @@
+use nu_engine::EvaluationContext;
+use nu_errors::ShellError;
+use std::error::Error;
+
+#[allow(unused_imports)]
+use std::sync::atomic::Ordering;
+
+#[allow(unused_imports)]
+use nu_engine::script::LineResult;
+
+#[cfg(feature = "rustyline-support")]
+use crate::keybinding::{convert_keyevent, KeyCode};
+
+#[cfg(feature = "rustyline-support")]
+use crate::shell::Helper;
+
+#[cfg(feature = "rustyline-support")]
+use rustyline::{
+    self,
+    config::Configurer,
+    config::{ColorMode, CompletionType, Config},
+    error::ReadlineError,
+    line_buffer::LineBuffer,
+    At, Cmd, ConditionalEventHandler, Editor, EventHandler, Modifiers, Movement, Word,
+};
+
+#[cfg(feature = "rustyline-support")]
+pub fn convert_rustyline_result_to_string(input: Result<String, ReadlineError>) -> LineResult {
+    match input {
+        Ok(s) if s == "history -c" || s == "history --clear" => LineResult::ClearHistory,
+        Ok(s) => LineResult::Success(s),
+        Err(ReadlineError::Interrupted) => LineResult::CtrlC,
+        Err(ReadlineError::Eof) => LineResult::CtrlD,
+        Err(err) => {
+            eprintln!("Error: {:?}", err);
+            LineResult::Break
+        }
+    }
+}
+
+#[derive(Clone)]
+#[cfg(feature = "rustyline-support")]
+struct PartialCompleteHintHandler;
+
+#[cfg(feature = "rustyline-support")]
+impl ConditionalEventHandler for PartialCompleteHintHandler {
+    fn handle(
+        &self,
+        _evt: &rustyline::Event,
+        _n: rustyline::RepeatCount,
+        _positive: bool,
+        ctx: &rustyline::EventContext,
+    ) -> Option<Cmd> {
+        Some(match ctx.hint_text() {
+            Some(hint_text) if ctx.pos() == ctx.line().len() => {
+                let mut line_buffer = LineBuffer::with_capacity(hint_text.len());
+                line_buffer.update(hint_text, 0);
+                line_buffer.move_to_next_word(At::AfterEnd, Word::Vi, 1);
+
+                let text = hint_text[0..line_buffer.pos()].to_string();
+
+                Cmd::Insert(1, text)
+            }
+            _ => Cmd::Move(Movement::ForwardWord(1, At::AfterEnd, Word::Vi)),
+        })
+    }
+}
+
+#[cfg(feature = "rustyline-support")]
+pub fn default_rustyline_editor_configuration() -> Editor<Helper> {
+    #[cfg(windows)]
+    const DEFAULT_COMPLETION_MODE: CompletionType = CompletionType::Circular;
+    #[cfg(not(windows))]
+    const DEFAULT_COMPLETION_MODE: CompletionType = CompletionType::List;
+
+    let config = Config::builder()
+        .check_cursor_position(true)
+        .color_mode(ColorMode::Forced)
+        .history_ignore_dups(false)
+        .max_history_size(10_000)
+        .build();
+    let mut rl: Editor<_> = Editor::with_config(config);
+
+    // add key bindings to move over a whole word with Ctrl+ArrowLeft and Ctrl+ArrowRight
+    //M modifier, E KeyEvent, K KeyCode
+    rl.bind_sequence(
+        convert_keyevent(KeyCode::Left, Some(Modifiers::CTRL)),
+        Cmd::Move(Movement::BackwardWord(1, Word::Vi)),
+    );
+
+    rl.bind_sequence(
+        convert_keyevent(KeyCode::Right, Some(Modifiers::CTRL)),
+        EventHandler::Conditional(Box::new(PartialCompleteHintHandler)),
+    );
+
+    // workaround for multiline-paste hang in rustyline (see https://github.com/kkawakam/rustyline/issues/202)
+    rl.bind_sequence(
+        convert_keyevent(KeyCode::BracketedPasteStart, None),
+        rustyline::Cmd::Noop,
+    );
+    // Let's set the defaults up front and then override them later if the user indicates
+    // defaults taken from here https://github.com/kkawakam/rustyline/blob/2fe886c9576c1ea13ca0e5808053ad491a6fe049/src/config.rs#L150-L167
+    rl.set_max_history_size(100);
+    rl.set_history_ignore_dups(true);
+    rl.set_history_ignore_space(false);
+    rl.set_completion_type(DEFAULT_COMPLETION_MODE);
+    rl.set_completion_prompt_limit(100);
+    rl.set_keyseq_timeout(-1);
+    rl.set_edit_mode(rustyline::config::EditMode::Emacs);
+    rl.set_auto_add_history(false);
+    rl.set_bell_style(rustyline::config::BellStyle::default());
+    rl.set_color_mode(rustyline::ColorMode::Enabled);
+    rl.set_tab_stop(8);
+
+    if let Err(e) = crate::keybinding::load_keybindings(&mut rl) {
+        println!("Error loading keybindings: {:?}", e);
+    }
+
+    rl
+}
+
+#[cfg(feature = "rustyline-support")]
+pub fn configure_rustyline_editor(
+    rl: &mut Editor<Helper>,
+    config: &dyn nu_data::config::Conf,
+) -> Result<(), ShellError> {
+    #[cfg(windows)]
+    const DEFAULT_COMPLETION_MODE: CompletionType = CompletionType::Circular;
+    #[cfg(not(windows))]
+    const DEFAULT_COMPLETION_MODE: CompletionType = CompletionType::List;
+
+    if let Some(line_editor_vars) = config.var("line_editor") {
+        for (idx, value) in line_editor_vars.row_entries() {
+            match idx.as_ref() {
+                "max_history_size" => {
+                    if let Ok(max_history_size) = value.as_u64() {
+                        rl.set_max_history_size(max_history_size as usize);
+                    }
+                }
+                "history_duplicates" => {
+                    // history_duplicates = match value.as_string() {
+                    //     Ok(s) if s.to_lowercase() == "alwaysadd" => {
+                    //         rustyline::config::HistoryDuplicates::AlwaysAdd
+                    //     }
+                    //     Ok(s) if s.to_lowercase() == "ignoreconsecutive" => {
+                    //         rustyline::config::HistoryDuplicates::IgnoreConsecutive
+                    //     }
+                    //     _ => rustyline::config::HistoryDuplicates::AlwaysAdd,
+                    // };
+                    if let Ok(history_duplicates) = value.as_bool() {
+                        rl.set_history_ignore_dups(history_duplicates);
+                    }
+                }
+                "history_ignore_space" => {
+                    if let Ok(history_ignore_space) = value.as_bool() {
+                        rl.set_history_ignore_space(history_ignore_space);
+                    }
+                }
+                "completion_type" => {
+                    let completion_type = match value.as_string() {
+                        Ok(s) if s.to_lowercase() == "circular" => {
+                            rustyline::config::CompletionType::Circular
+                        }
+                        Ok(s) if s.to_lowercase() == "list" => {
+                            rustyline::config::CompletionType::List
+                        }
+                        #[cfg(all(unix, feature = "with-fuzzy"))]
+                        Ok(s) if s.to_lowercase() == "fuzzy" => {
+                            rustyline::config::CompletionType::Fuzzy
+                        }
+                        _ => DEFAULT_COMPLETION_MODE,
+                    };
+                    rl.set_completion_type(completion_type);
+                }
+                "completion_prompt_limit" => {
+                    if let Ok(completion_prompt_limit) = value.as_u64() {
+                        rl.set_completion_prompt_limit(completion_prompt_limit as usize);
+                    }
+                }
+                "keyseq_timeout_ms" => {
+                    if let Ok(keyseq_timeout_ms) = value.as_u64() {
+                        rl.set_keyseq_timeout(keyseq_timeout_ms as i32);
+                    }
+                }
+                "edit_mode" => {
+                    let edit_mode = match value.as_string() {
+                        Ok(s) if s.to_lowercase() == "vi" => rustyline::config::EditMode::Vi,
+                        Ok(s) if s.to_lowercase() == "emacs" => rustyline::config::EditMode::Emacs,
+                        _ => rustyline::config::EditMode::Emacs,
+                    };
+                    rl.set_edit_mode(edit_mode);
+                    // Note: When edit_mode is Emacs, the keyseq_timeout_ms is set to -1
+                    // no matter what you may have configured. This is so that key chords
+                    // can be applied without having to do them in a given timeout. So,
+                    // it essentially turns off the keyseq timeout.
+                }
+                "auto_add_history" => {
+                    if let Ok(auto_add_history) = value.as_bool() {
+                        rl.set_auto_add_history(auto_add_history);
+                    }
+                }
+                "bell_style" => {
+                    let bell_style = match value.as_string() {
+                        Ok(s) if s.to_lowercase() == "audible" => {
+                            rustyline::config::BellStyle::Audible
+                        }
+                        Ok(s) if s.to_lowercase() == "none" => rustyline::config::BellStyle::None,
+                        Ok(s) if s.to_lowercase() == "visible" => {
+                            rustyline::config::BellStyle::Visible
+                        }
+                        _ => rustyline::config::BellStyle::default(),
+                    };
+                    rl.set_bell_style(bell_style);
+                }
+                "color_mode" => {
+                    let color_mode = match value.as_string() {
+                        Ok(s) if s.to_lowercase() == "enabled" => rustyline::ColorMode::Enabled,
+                        Ok(s) if s.to_lowercase() == "forced" => rustyline::ColorMode::Forced,
+                        Ok(s) if s.to_lowercase() == "disabled" => rustyline::ColorMode::Disabled,
+                        _ => rustyline::ColorMode::Enabled,
+                    };
+                    rl.set_color_mode(color_mode);
+                }
+                "tab_stop" => {
+                    if let Ok(tab_stop) = value.as_u64() {
+                        rl.set_tab_stop(tab_stop as usize);
+                    }
+                }
+                _ => (),
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(feature = "rustyline-support")]
+pub fn nu_line_editor_helper(
+    context: &EvaluationContext,
+    config: &dyn nu_data::config::Conf,
+) -> crate::shell::Helper {
+    let hinter = rustyline_hinter(config);
+    crate::shell::Helper::new(context.clone(), hinter)
+}
+
+#[cfg(feature = "rustyline-support")]
+pub fn rustyline_hinter(
+    config: &dyn nu_data::config::Conf,
+) -> Option<rustyline::hint::HistoryHinter> {
+    if let Some(line_editor_vars) = config.var("line_editor") {
+        for (idx, value) in line_editor_vars.row_entries() {
+            if idx == "show_hints" && value.as_bool() == Ok(false) {
+                return None;
+            }
+        }
+    }
+
+    Some(rustyline::hint::HistoryHinter {})
+}
+
+pub fn configure_ctrl_c(_context: &EvaluationContext) -> Result<(), Box<dyn Error>> {
+    #[cfg(feature = "ctrlc")]
+    {
+        let cc = _context.ctrl_c().clone();
+
+        ctrlc::set_handler(move || {
+            cc.store(true, Ordering::SeqCst);
+        })?;
+
+        if _context.ctrl_c().load(Ordering::SeqCst) {
+            _context.ctrl_c().store(false, Ordering::SeqCst);
+        }
+    }
+
+    Ok(())
+}

crates/nu-cli/src/shell.rs

@@ -0,0 +1,234 @@
+use nu_ansi_term::Color;
+use nu_completion::NuCompleter;
+use nu_engine::{DefaultPalette, EvaluationContext, Painter};
+use nu_source::{Tag, Tagged};
+use std::borrow::Cow::{self, Owned};
+
+pub struct Helper {
+    completer: NuCompleter,
+    hinter: Option<rustyline::hint::HistoryHinter>,
+    context: EvaluationContext,
+    pub colored_prompt: String,
+    validator: NuValidator,
+}
+
+impl Helper {
+    pub(crate) fn new(
+        context: EvaluationContext,
+        hinter: Option<rustyline::hint::HistoryHinter>,
+    ) -> Helper {
+        Helper {
+            completer: NuCompleter {},
+            hinter,
+            context,
+            colored_prompt: String::new(),
+            validator: NuValidator {},
+        }
+    }
+}
+
+use nu_protocol::{SignatureRegistry, VariableRegistry};
+struct CompletionContext<'a>(&'a EvaluationContext);
+
+impl<'a> nu_completion::CompletionContext for CompletionContext<'a> {
+    fn signature_registry(&self) -> &dyn SignatureRegistry {
+        &self.0.scope
+    }
+
+    fn scope(&self) -> &dyn nu_parser::ParserScope {
+        &self.0.scope
+    }
+
+    fn source(&self) -> &EvaluationContext {
+        self.as_ref()
+    }
+
+    fn variable_registry(&self) -> &dyn VariableRegistry {
+        self.0
+    }
+}
+
+impl<'a> AsRef<EvaluationContext> for CompletionContext<'a> {
+    fn as_ref(&self) -> &EvaluationContext {
+        self.0
+    }
+}
+
+pub struct CompletionSuggestion(nu_completion::Suggestion);
+
+impl rustyline::completion::Candidate for CompletionSuggestion {
+    fn display(&self) -> &str {
+        &self.0.display
+    }
+
+    fn replacement(&self) -> &str {
+        &self.0.replacement
+    }
+}
+
+impl rustyline::completion::Completer for Helper {
+    type Candidate = CompletionSuggestion;
+
+    fn complete(
+        &self,
+        line: &str,
+        pos: usize,
+        _ctx: &rustyline::Context<'_>,
+    ) -> Result<(usize, Vec<Self::Candidate>), rustyline::error::ReadlineError> {
+        let ctx = CompletionContext(&self.context);
+        let (position, suggestions) = self.completer.complete(line, pos, &ctx);
+        let suggestions = suggestions.into_iter().map(CompletionSuggestion).collect();
+        Ok((position, suggestions))
+    }
+
+    fn update(&self, line: &mut rustyline::line_buffer::LineBuffer, start: usize, elected: &str) {
+        let end = line.pos();
+        line.replace(start..end, elected)
+    }
+}
+
+impl rustyline::hint::Hinter for Helper {
+    type Hint = String;
+    fn hint(&self, line: &str, pos: usize, ctx: &rustyline::Context<'_>) -> Option<String> {
+        match &self.hinter {
+            Some(the_hinter) => the_hinter.hint(line, pos, ctx),
+            None => Some("".to_string()),
+        }
+    }
+}
+
+impl rustyline::highlight::Highlighter for Helper {
+    fn highlight_prompt<'b, 's: 'b, 'p: 'b>(
+        &'s self,
+        prompt: &'p str,
+        default: bool,
+    ) -> Cow<'b, str> {
+        use std::borrow::Cow::Borrowed;
+
+        if default {
+            Borrowed(&self.colored_prompt)
+        } else {
+            Borrowed(prompt)
+        }
+    }
+
+    fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
+        Owned(Color::DarkGray.prefix().to_string() + hint + nu_ansi_term::ansi::RESET)
+    }
+
+    fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
+        let cfg = &self.context.configs().lock();
+        if let Some(palette) = &cfg.syntax_config {
+            Painter::paint_string(line, &self.context.scope, palette)
+        } else {
+            Painter::paint_string(line, &self.context.scope, &DefaultPalette {})
+        }
+    }
+
+    fn highlight_char(&self, _line: &str, _pos: usize) -> bool {
+        true
+    }
+}
+
+impl rustyline::validate::Validator for Helper {
+    fn validate(
+        &self,
+        ctx: &mut rustyline::validate::ValidationContext,
+    ) -> rustyline::Result<rustyline::validate::ValidationResult> {
+        self.validator.validate(ctx)
+    }
+
+    fn validate_while_typing(&self) -> bool {
+        self.validator.validate_while_typing()
+    }
+}
+
+struct NuValidator {}
+
+impl rustyline::validate::Validator for NuValidator {
+    fn validate(
+        &self,
+        ctx: &mut rustyline::validate::ValidationContext,
+    ) -> rustyline::Result<rustyline::validate::ValidationResult> {
+        let src = ctx.input();
+
+        let (tokens, err) = nu_parser::lex(src, 0, nu_parser::NewlineMode::Normal);
+        if let Some(err) = err {
+            if let nu_errors::ParseErrorReason::Eof { .. } = err.reason() {
+                return Ok(rustyline::validate::ValidationResult::Incomplete);
+            }
+        }
+
+        let (_, err) = nu_parser::parse_block(tokens);
+
+        if let Some(err) = err {
+            if let nu_errors::ParseErrorReason::Eof { .. } = err.reason() {
+                return Ok(rustyline::validate::ValidationResult::Incomplete);
+            }
+        }
+
+        Ok(rustyline::validate::ValidationResult::Valid(None))
+    }
+}
+
+#[allow(unused)]
+fn vec_tag<T>(input: Vec<Tagged<T>>) -> Option<Tag> {
+    let mut iter = input.iter();
+    let first = iter.next()?.tag.clone();
+    let last = iter.last();
+
+    Some(match last {
+        None => first,
+        Some(last) => first.until(&last.tag),
+    })
+}
+
+impl rustyline::Helper for Helper {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use nu_engine::EvaluationContext;
+    use rustyline::completion::Completer;
+    use rustyline::line_buffer::LineBuffer;
+
+    #[ignore]
+    #[test]
+    fn closing_quote_should_replaced() {
+        let text = "cd \"folder with spaces\\subdirectory\\\"";
+        let replacement = "\"folder with spaces\\subdirectory\\subsubdirectory\\\"";
+
+        let mut buffer = LineBuffer::with_capacity(256);
+        buffer.insert_str(0, text);
+        buffer.set_pos(text.len() - 1);
+
+        let helper = Helper::new(EvaluationContext::basic(), None);
+
+        helper.update(&mut buffer, "cd ".len(), replacement);
+
+        assert_eq!(
+            buffer.as_str(),
+            "cd \"folder with spaces\\subdirectory\\subsubdirectory\\\""
+        );
+    }
+
+    #[ignore]
+    #[test]
+    fn replacement_with_cursor_in_text() {
+        let text = "cd \"folder with spaces\\subdirectory\\\"";
+        let replacement = "\"folder with spaces\\subdirectory\\subsubdirectory\\\"";
+
+        let mut buffer = LineBuffer::with_capacity(256);
+        buffer.insert_str(0, text);
+        buffer.set_pos(text.len() - 30);
+
+        let helper = Helper::new(EvaluationContext::basic(), None);
+
+        helper.update(&mut buffer, "cd ".len(), replacement);
+
+        assert_eq!(
+            buffer.as_str(),
+            "cd \"folder with spaces\\subdirectory\\subsubdirectory\\\""
+        );
+    }
+}

crates/nu-command/Cargo.toml

@@ -0,0 +1,123 @@
+[package]
+authors = ["The Nu Project Contributors"]
+build = "build.rs"
+description = "CLI for nushell"
+edition = "2018"
+license = "MIT"
+name = "nu-command"
+version = "0.40.0"
+
+[lib]
+doctest = false
+
+[dependencies]
+nu-data = { version = "0.40.0", path="../nu-data" }
+nu-engine = { version = "0.40.0", path="../nu-engine" }
+nu-errors = { version = "0.40.0", path="../nu-errors" }
+nu-json = { version = "0.40.0", path="../nu-json" }
+nu-path = { version = "0.40.0", path="../nu-path" }
+nu-parser = { version = "0.40.0", path="../nu-parser" }
+nu-plugin = { version = "0.40.0", path="../nu-plugin" }
+nu-protocol = { version = "0.40.0", path="../nu-protocol" }
+nu-serde = { version = "0.40.0", path="../nu-serde" }
+nu-source = { version = "0.40.0", path="../nu-source" }
+nu-stream = { version = "0.40.0", path="../nu-stream" }
+nu-table = { version = "0.40.0", path="../nu-table" }
+nu-test-support = { version = "0.40.0", path="../nu-test-support" }
+nu-value-ext = { version = "0.40.0", path="../nu-value-ext" }
+nu-ansi-term = { version = "0.40.0", path="../nu-ansi-term" }
+nu-pretty-hex = { version = "0.40.0", path="../nu-pretty-hex" }
+
+url = "2.2.1"
+mime = "0.3.16"
+Inflector = "0.11"
+arboard = { version="1.1.0", optional=true }
+base64 = "0.13.0"
+bigdecimal = { package = "bigdecimal-rs", version = "0.2.1", features = ["serde"] }
+calamine = "0.18.0"
+chrono = { version="0.4.19", features=["serde"] }
+chrono-tz = "0.5.3"
+crossterm = { version="0.19.0", optional=true }
+csv = "1.1.3"
+ctrlc = { version="3.1.7", optional=true }
+derive-new = "0.5.8"
+dirs-next = "2.0.0"
+dtparse = "1.2.0"
+eml-parser = "0.1.0"
+encoding_rs = "0.8.28"
+filesize = "0.2.0"
+futures = { version="0.3.12", features=["compat", "io-compat"] }
+glob = "0.3.0"
+htmlescape = "0.3.1"
+ical = "0.7.0"
+indexmap = { version="1.7", features=["serde-1"] }
+itertools = "0.10.0"
+lazy_static = "1.*"
+log = "0.4.14"
+md-5 = "0.9.1"
+meval = "0.2.0"
+num-bigint = { version="0.3.1", features=["serde"] }
+num-format = { version="0.4.0", features=["with-num-bigint"] }
+num-traits = "0.2.14"
+parking_lot = "0.11.1"
+quick-xml = "0.22"
+rand = "0.8"
+regex = "1.4.3"
+reqwest = {version = "0.11", optional = true }
+roxmltree = "0.14.0"
+rust-embed = "5.9.0"
+rustyline = { version="9.0.0", optional=true }
+serde = { version="1.0.123", features=["derive"] }
+serde_ini = "0.2.0"
+serde_json = "1.0.61"
+serde_urlencoded = "0.7.0"
+serde_yaml = "0.8.16"
+sha2 = "0.9.3"
+strip-ansi-escapes = "0.1.0"
+sysinfo = { version = "0.20.2", optional = true }
+thiserror = "1.0.26"
+term = { version="0.7.0", optional=true }
+term_size = "0.3.2"
+titlecase = "1.1.0"
+tokio = { version = "1", features = ["rt-multi-thread"], optional = true }
+toml = "0.5.8"
+trash = { version="1.3.0", optional=true }
+unicode-segmentation = "1.8"
+uuid_crate = { package="uuid", version="0.8.2", features=["v4"], optional=true }
+which = { version="4.1.0", optional=true }
+zip = { version="0.5.9", optional=true }
+digest = "0.9.0"
+
+[dependencies.polars]
+version = "0.17.0"
+optional = true
+features = ["parquet", "json", "random", "pivot", "strings", "is_in", "temporal", "cum_agg", "rolling_window"]
+
+[target.'cfg(unix)'.dependencies]
+umask = "1.0.0"
+users = "0.11.0"
+
+# TODO this will be possible with new dependency resolver
+#   (currently on nightly behind -Zfeatures=itarget):
+#   https://github.com/rust-lang/cargo/issues/7914
+# [target.'cfg(not(windows))'.dependencies]
+# num-format = { version = "0.4", features = ["with-system-locale"] }
+
+[build-dependencies]
+shadow-rs = "0.6"
+
+[dev-dependencies]
+quickcheck = "1.0.3"
+quickcheck_macros = "1.0.0"
+hamcrest2 = "0.3.0"
+
+[features]
+clipboard-cli = ["arboard"]
+rustyline-support = ["rustyline"]
+stable = []
+trash-support = ["trash"]
+dataframe = ["nu-protocol/dataframe", "polars"]
+fetch = ["reqwest", "tokio"]
+post = ["reqwest", "tokio"]
+sys = ["sysinfo"]
+ps = ["sysinfo"]

crates/nu-command/README.md

@@ -0,0 +1,7 @@
+# nu-command
+
+The Nu command crate contains the full set of internal commands, that is, the commands that can be form the set of built-in commands in a Nushell engine.
+
+The default set of commands that Nushell ships with can be found in the [default context](src/default_context.rs).
+
+The commands themselves live in the [commands module](src/commands/).

crates/nu-command/build.rs

@@ -0,0 +1,3 @@
+fn main() -> shadow_rs::SdResult<()> {
+    shadow_rs::new()
+}

crates/nu-command/src/args.rs

@@ -1,4 +1,4 @@
-use crate::data::Value;
+use nu_protocol::Value;
 
 #[derive(Debug)]
 pub enum LogLevel {}

crates/nu-command/src/classified/dynamic.rs

@@ -0,0 +1,7 @@
+use derive_new::new;
+use nu_protocol::hir;
+
+#[derive(new, Debug)]
+pub(crate) struct Command {
+    pub(crate) args: hir::Call,
+}

crates/nu-command/src/classified/external.rs

@@ -0,0 +1,713 @@
+use crate::prelude::*;
+use nu_engine::{evaluate_baseline_expr, BufCodecReader};
+use nu_engine::{MaybeTextCodec, StringOrBinary};
+use nu_test_support::NATIVE_PATH_ENV_VAR;
+use parking_lot::Mutex;
+
+#[allow(unused)]
+use std::env;
+use std::io::Write;
+use std::path::PathBuf;
+use std::process::{Command, Stdio};
+use std::sync::mpsc;
+use std::{borrow::Cow, io::BufReader};
+
+use log::trace;
+
+use nu_errors::ShellError;
+use nu_protocol::hir::Expression;
+use nu_protocol::hir::{ExternalCommand, ExternalRedirection};
+use nu_protocol::{Primitive, ShellTypeName, UntaggedValue, Value};
+use nu_source::Tag;
+
+#[cfg(feature = "which")]
+use which::which_in;
+
+pub(crate) fn run_external_command(
+    command: ExternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+) -> Result<InputStream, ShellError> {
+    trace!(target: "nu::run::external", "-> {}", command.name);
+
+    context.sync_path_to_env();
+    if !context.host().lock().is_external_cmd(&command.name) {
+        return Err(ShellError::labeled_error(
+            "Command not found",
+            format!("command {} not found", &command.name),
+            &command.name_tag,
+        ));
+    }
+
+    run_with_stdin(command, context, input, external_redirection)
+}
+
+#[allow(unused)]
+fn trim_double_quotes(input: &str) -> String {
+    let mut chars = input.chars();
+
+    match (chars.next(), chars.next_back()) {
+        (Some('"'), Some('"')) => chars.collect(),
+        _ => input.to_string(),
+    }
+}
+
+#[allow(unused)]
+fn escape_where_needed(input: &str) -> String {
+    input.split(' ').join("\\ ").split('\'').join("\\'")
+}
+
+fn run_with_stdin(
+    command: ExternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+) -> Result<InputStream, ShellError> {
+    let path = context.shell_manager().path();
+
+    let mut command_args = vec![];
+    for arg in command.args.iter() {
+        let is_literal = matches!(arg.expr, Expression::Literal(_));
+        let value = evaluate_baseline_expr(arg, context)?;
+
+        // Skip any arguments that don't really exist, treating them as optional
+        // FIXME: we may want to preserve the gap in the future, though it's hard to say
+        // what value we would put in its place.
+        if value.value.is_none() {
+            continue;
+        }
+
+        // Do the cleanup that we need to do on any argument going out:
+        match &value.value {
+            UntaggedValue::Table(table) => {
+                for t in table {
+                    match &t.value {
+                        UntaggedValue::Primitive(_) => {
+                            command_args.push((
+                                t.convert_to_string().trim_end_matches('\n').to_string(),
+                                is_literal,
+                            ));
+                        }
+                        _ => {
+                            return Err(ShellError::labeled_error(
+                                "Could not convert to positional arguments",
+                                "could not convert to positional arguments",
+                                value.tag(),
+                            ));
+                        }
+                    }
+                }
+            }
+            _ => {
+                let trimmed_value_string = value.as_string()?.trim_end_matches('\n').to_string();
+                //let trimmed_value_string = trim_quotes(&trimmed_value_string);
+                command_args.push((trimmed_value_string, is_literal));
+            }
+        }
+    }
+
+    let process_args = command_args
+        .iter()
+        .map(|(arg, _is_literal)| {
+            let arg = nu_path::expand_tilde(arg).to_string_lossy().to_string();
+
+            #[cfg(not(windows))]
+            {
+                if !_is_literal {
+                    let escaped = escape_double_quotes(&arg);
+                    add_double_quotes(&escaped)
+                } else {
+                    let trimmed = trim_double_quotes(&arg);
+                    if trimmed != arg {
+                        escape_where_needed(&trimmed)
+                    } else {
+                        trimmed
+                    }
+                }
+            }
+            #[cfg(windows)]
+            {
+                if let Some(unquoted) = remove_quotes(&arg) {
+                    unquoted.to_string()
+                } else {
+                    arg.to_string()
+                }
+            }
+        })
+        .collect::<Vec<String>>();
+
+    spawn(
+        &command,
+        &path,
+        &process_args[..],
+        input,
+        external_redirection,
+        &context.scope,
+    )
+}
+
+/// Spawn a direct exe
+#[allow(unused)]
+fn spawn_exe(full_path: PathBuf, args: &[String]) -> Command {
+    let mut process = Command::new(full_path);
+    for arg in args {
+        process.arg(&arg);
+    }
+    process
+}
+
+/// Spawn a cmd command with `cmd /c args...`
+fn spawn_cmd_command(command: &ExternalCommand, args: &[String]) -> Command {
+    let mut process = Command::new("cmd");
+    process.arg("/c");
+    process.arg(&command.name);
+    for arg in args {
+        // Clean the args before we use them:
+        // https://stackoverflow.com/questions/1200235/how-to-pass-a-quoted-pipe-character-to-cmd-exe
+        // cmd.exe needs to have a caret to escape a pipe
+        let arg = arg.replace("|", "^|");
+        process.arg(&arg);
+    }
+    process
+}
+
+/// Spawn a sh command with `sh -c args...`
+fn spawn_sh_command(command: &ExternalCommand, args: &[String]) -> Command {
+    let cmd_with_args = vec![command.name.clone(), args.join(" ")].join(" ");
+    let mut process = Command::new("sh");
+    process.arg("-c").arg(cmd_with_args);
+    process
+}
+
+/// a function to spawn any external command
+#[allow(unused)] // for minimal builds cwd is unused
+fn spawn_any(command: &ExternalCommand, args: &[String], cwd: &str) -> Command {
+    // resolve the executable name if it is spawnable directly
+    #[cfg(feature = "which")]
+    // TODO add more available paths to `env::var_os("PATH")`?
+    if let Result::Ok(full_path) = which_in(&command.name, env::var_os("PATH"), cwd) {
+        if let Some(extension) = full_path.extension() {
+            #[cfg(windows)]
+            if extension.eq_ignore_ascii_case("exe") {
+                // if exe spawn it directly
+                return spawn_exe(full_path, args);
+            } else {
+                // TODO implement special care for various executable types such as .bat, .ps1, .cmd, etc
+                // https://github.com/mklement0/Native/blob/e0e0b8785cad39a73053e35084d1f60d87fbac58/Native.psm1#L749
+                // otherwise shell out to cmd
+                return spawn_cmd_command(command, args);
+            }
+            #[cfg(not(windows))]
+            if !["sh", "bash"]
+                .iter()
+                .any(|ext| extension.eq_ignore_ascii_case(ext))
+            {
+                // if exe spawn it directly
+                return spawn_exe(full_path, args);
+            } else {
+                // otherwise shell out to sh
+                return spawn_sh_command(command, args);
+            }
+        }
+    }
+    // in all the other cases shell out
+    if cfg!(windows) {
+        spawn_cmd_command(command, args)
+    } else {
+        // TODO what happens if that os doesn't support spawning sh?
+        spawn_sh_command(command, args)
+    }
+}
+
+fn spawn(
+    command: &ExternalCommand,
+    path: &str,
+    args: &[String],
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+    scope: &Scope,
+) -> Result<InputStream, ShellError> {
+    let command = command.clone();
+
+    let mut process = spawn_any(&command, args, path);
+    process.current_dir(path);
+    trace!(target: "nu::run::external", "cwd = {:?}", &path);
+
+    process.env_clear();
+    process.envs(scope.get_env_vars());
+
+    // We want stdout regardless of what
+    // we are doing ($it case or pipe stdin)
+    match external_redirection {
+        ExternalRedirection::Stdout => {
+            process.stdout(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stdout pipe");
+        }
+        ExternalRedirection::Stderr => {
+            process.stderr(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stderr pipe");
+        }
+        ExternalRedirection::StdoutAndStderr => {
+            process.stdout(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stdout pipe");
+            process.stderr(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stderr pipe");
+        }
+        _ => {}
+    }
+
+    // open since we have some contents for stdin
+    if !input.is_empty() {
+        process.stdin(Stdio::piped());
+        trace!(target: "nu::run::external", "set up stdin pipe");
+    }
+
+    trace!(target: "nu::run::external", "built command {:?}", process);
+
+    // TODO Switch to async_std::process once it's stabilized
+    match process.spawn() {
+        Ok(mut child) => {
+            let (tx, rx) = mpsc::sync_channel(0);
+
+            let mut stdin = child.stdin.take();
+
+            let stdin_write_tx = tx.clone();
+            let stdout_read_tx = tx;
+            let stdin_name_tag = command.name_tag.clone();
+            let stdout_name_tag = command.name_tag;
+
+            std::thread::spawn(move || {
+                if !input.is_empty() {
+                    let mut stdin_write = stdin
+                        .take()
+                        .expect("Internal error: could not get stdin pipe for external command");
+
+                    for value in input {
+                        match &value.value {
+                            UntaggedValue::Primitive(Primitive::Nothing) => continue,
+                            UntaggedValue::Primitive(Primitive::String(s)) => {
+                                if stdin_write.write(s.as_bytes()).is_err() {
+                                    // Other side has closed, so exit
+                                    return Ok(());
+                                }
+                            }
+                            UntaggedValue::Primitive(Primitive::Binary(b)) => {
+                                if stdin_write.write(b).is_err() {
+                                    // Other side has closed, so exit
+                                    return Ok(());
+                                }
+                            }
+                            unsupported => {
+                                println!("Unsupported: {:?}", unsupported);
+                                let _ = stdin_write_tx.send(Ok(Value {
+                                    value: UntaggedValue::Error(ShellError::labeled_error(
+                                        format!(
+                                            "Received unexpected type from pipeline ({})",
+                                            unsupported.type_name()
+                                        ),
+                                        format!(
+                                            "expected a string, got {} as input",
+                                            unsupported.type_name()
+                                        ),
+                                        stdin_name_tag.clone(),
+                                    )),
+                                    tag: stdin_name_tag,
+                                }));
+                                return Err(());
+                            }
+                        };
+                    }
+                }
+
+                Ok(())
+            });
+
+            std::thread::spawn(move || {
+                if external_redirection == ExternalRedirection::Stdout
+                    || external_redirection == ExternalRedirection::StdoutAndStderr
+                {
+                    let stdout = if let Some(stdout) = child.stdout.take() {
+                        stdout
+                    } else {
+                        let _ = stdout_read_tx.send(Ok(Value {
+                            value: UntaggedValue::Error(ShellError::labeled_error(
+                                "Can't redirect the stdout for external command",
+                                "can't redirect stdout",
+                                &stdout_name_tag,
+                            )),
+                            tag: stdout_name_tag,
+                        }));
+                        return Err(());
+                    };
+
+                    // let file = futures::io::AllowStdIo::new(stdout);
+                    // let stream = FramedRead::new(file, MaybeTextCodec::default());
+                    let buf_read = BufReader::new(stdout);
+                    let buf_codec = BufCodecReader::new(buf_read, MaybeTextCodec::default());
+
+                    for line in buf_codec {
+                        match line {
+                            Ok(line) => match line {
+                                StringOrBinary::String(s) => {
+                                    let result = stdout_read_tx.send(Ok(Value {
+                                        value: UntaggedValue::Primitive(Primitive::String(
+                                            s.clone(),
+                                        )),
+                                        tag: stdout_name_tag.clone(),
+                                    }));
+
+                                    if result.is_err() {
+                                        break;
+                                    }
+                                }
+                                StringOrBinary::Binary(b) => {
+                                    let result = stdout_read_tx.send(Ok(Value {
+                                        value: UntaggedValue::Primitive(Primitive::Binary(
+                                            b.into_iter().collect(),
+                                        )),
+                                        tag: stdout_name_tag.clone(),
+                                    }));
+
+                                    if result.is_err() {
+                                        break;
+                                    }
+                                }
+                            },
+                            Err(e) => {
+                                // If there's an exit status, it makes sense that we may error when
+                                // trying to read from its stdout pipe (likely been closed). In that
+                                // case, don't emit an error.
+                                let should_error = match child.wait() {
+                                    Ok(exit_status) => !exit_status.success(),
+                                    Err(_) => true,
+                                };
+
+                                if should_error {
+                                    let _ = stdout_read_tx.send(Ok(Value {
+                                        value: UntaggedValue::Error(ShellError::labeled_error(
+                                            format!("Unable to read from stdout ({})", e),
+                                            "unable to read from stdout",
+                                            &stdout_name_tag,
+                                        )),
+                                        tag: stdout_name_tag.clone(),
+                                    }));
+                                }
+
+                                return Ok(());
+                            }
+                        }
+                    }
+                }
+                if external_redirection == ExternalRedirection::Stderr
+                    || external_redirection == ExternalRedirection::StdoutAndStderr
+                {
+                    let stderr = if let Some(stderr) = child.stderr.take() {
+                        stderr
+                    } else {
+                        let _ = stdout_read_tx.send(Ok(Value {
+                            value: UntaggedValue::Error(ShellError::labeled_error(
+                                "Can't redirect the stderr for external command",
+                                "can't redirect stderr",
+                                &stdout_name_tag,
+                            )),
+                            tag: stdout_name_tag,
+                        }));
+                        return Err(());
+                    };
+
+                    // let file = futures::io::AllowStdIo::new(stderr);
+                    // let stream = FramedRead::new(file, MaybeTextCodec::default());
+                    let buf_reader = BufReader::new(stderr);
+                    let buf_codec = BufCodecReader::new(buf_reader, MaybeTextCodec::default());
+
+                    for line in buf_codec {
+                        match line {
+                            Ok(line) => match line {
+                                StringOrBinary::String(s) => {
+                                    let result = stdout_read_tx.send(Ok(Value {
+                                        value: UntaggedValue::Error(
+                                            ShellError::untagged_runtime_error(s),
+                                        ),
+                                        tag: stdout_name_tag.clone(),
+                                    }));
+
+                                    if result.is_err() {
+                                        break;
+                                    }
+                                }
+                                StringOrBinary::Binary(_) => {
+                                    let result = stdout_read_tx.send(Ok(Value {
+                                        value: UntaggedValue::Error(
+                                            ShellError::untagged_runtime_error("<binary stderr>"),
+                                        ),
+                                        tag: stdout_name_tag.clone(),
+                                    }));
+
+                                    if result.is_err() {
+                                        break;
+                                    }
+                                }
+                            },
+                            Err(e) => {
+                                // If there's an exit status, it makes sense that we may error when
+                                // trying to read from its stdout pipe (likely been closed). In that
+                                // case, don't emit an error.
+                                let should_error = match child.wait() {
+                                    Ok(exit_status) => !exit_status.success(),
+                                    Err(_) => true,
+                                };
+
+                                if should_error {
+                                    let _ = stdout_read_tx.send(Ok(Value {
+                                        value: UntaggedValue::Error(ShellError::labeled_error(
+                                            format!("Unable to read from stdout ({})", e),
+                                            "unable to read from stdout",
+                                            &stdout_name_tag,
+                                        )),
+                                        tag: stdout_name_tag.clone(),
+                                    }));
+                                }
+
+                                return Ok(());
+                            }
+                        }
+                    }
+                }
+
+                // We can give an error when we see a non-zero exit code, but this is different
+                // than what other shells will do.
+                let external_failed = match child.wait() {
+                    Err(_) => true,
+                    Ok(exit_status) => !exit_status.success(),
+                };
+
+                if external_failed {
+                    let cfg = nu_data::config::config(Tag::unknown());
+                    if let Ok(cfg) = cfg {
+                        if cfg.contains_key("nonzero_exit_errors") {
+                            let _ = stdout_read_tx.send(Ok(Value {
+                                value: UntaggedValue::Error(ShellError::labeled_error(
+                                    "External command failed",
+                                    "command failed",
+                                    &stdout_name_tag,
+                                )),
+                                tag: stdout_name_tag.clone(),
+                            }));
+                        }
+                    }
+                    let _ = stdout_read_tx.send(Ok(Value {
+                        value: UntaggedValue::nothing(),
+                        tag: stdout_name_tag,
+                    }));
+                }
+
+                Ok(())
+            });
+
+            let stream = ChannelReceiver::new(rx);
+            Ok(stream.into_input_stream())
+        }
+        Err(e) => Err(ShellError::labeled_error(
+            e.to_string(),
+            "failed to spawn",
+            &command.name_tag,
+        )),
+    }
+}
+
+struct ChannelReceiver {
+    rx: Arc<Mutex<mpsc::Receiver<Result<Value, ShellError>>>>,
+}
+
+impl ChannelReceiver {
+    pub fn new(rx: mpsc::Receiver<Result<Value, ShellError>>) -> Self {
+        Self {
+            rx: Arc::new(Mutex::new(rx)),
+        }
+    }
+}
+
+impl Iterator for ChannelReceiver {
+    type Item = Result<Value, ShellError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let rx = self.rx.lock();
+        match rx.recv() {
+            Ok(v) => Some(v),
+            Err(_) => None,
+        }
+    }
+}
+
+fn argument_is_quoted(argument: &str) -> bool {
+    if argument.len() < 2 {
+        return false;
+    }
+
+    (argument.starts_with('"') && argument.ends_with('"'))
+        || (argument.starts_with('\'') && argument.ends_with('\''))
+}
+
+#[allow(unused)]
+fn add_double_quotes(argument: &str) -> String {
+    format!("\"{}\"", argument)
+}
+
+#[allow(unused)]
+fn escape_double_quotes(argument: &str) -> Cow<'_, str> {
+    // allocate new string only if required
+    if argument.contains('"') {
+        Cow::Owned(argument.replace('"', r#"\""#))
+    } else {
+        Cow::Borrowed(argument)
+    }
+}
+
+#[allow(unused)]
+fn remove_quotes(argument: &str) -> Option<&str> {
+    if !argument_is_quoted(argument) {
+        return None;
+    }
+
+    let size = argument.len();
+
+    Some(&argument[1..size - 1])
+}
+
+#[allow(unused)]
+fn shell_os_paths() -> Vec<std::path::PathBuf> {
+    let mut original_paths = vec![];
+
+    if let Some(paths) = std::env::var_os(NATIVE_PATH_ENV_VAR) {
+        original_paths = std::env::split_paths(&paths).collect::<Vec<_>>();
+    }
+
+    original_paths
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{add_double_quotes, argument_is_quoted, escape_double_quotes, remove_quotes};
+    #[cfg(feature = "which")]
+    use super::{run_external_command, InputStream};
+
+    #[cfg(feature = "which")]
+    use nu_engine::EvaluationContext;
+
+    #[cfg(feature = "which")]
+    use nu_test_support::commands::ExternalBuilder;
+    // fn read(mut stream: OutputStream) -> Option<Value> {
+    //     match stream.try_next() {
+    //         Ok(val) => {
+    //             if let Some(val) = val {
+    //                 val.raw_value()
+    //             } else {
+    //                 None
+    //             }
+    //         }
+    //         Err(_) => None,
+    //     }
+    // }
+
+    #[cfg(feature = "which")]
+    fn non_existent_run() {
+        use nu_protocol::hir::ExternalRedirection;
+        let cmd = ExternalBuilder::for_name("i_dont_exist.exe").build();
+
+        let input = InputStream::empty();
+        let mut ctx = EvaluationContext::basic();
+
+        assert!(run_external_command(cmd, &mut ctx, input, ExternalRedirection::Stdout).is_err());
+    }
+
+    // fn failure_run() -> Result<(), ShellError> {
+    //     let cmd = ExternalBuilder::for_name("fail").build();
+
+    //     let mut ctx = crate::cli::EvaluationContext::basic().expect("There was a problem creating a basic context.");
+    //     let stream = run_external_command(cmd, &mut ctx, None, false)
+    //         ?
+    //         .expect("There was a problem running the external command.");
+
+    //     match read(stream.into()) {
+    //         Some(Value {
+    //             value: UntaggedValue::Error(_),
+    //             ..
+    //         }) => {}
+    //         None | _ => panic!("Command didn't fail."),
+    //     }
+
+    //     Ok(())
+    // }
+
+    // #[test]
+    // fn identifies_command_failed() -> Result<(), ShellError> {
+    //     block_on(failure_run())
+    // }
+
+    #[cfg(feature = "which")]
+    #[test]
+    fn identifies_command_not_found() {
+        non_existent_run()
+    }
+
+    #[test]
+    fn checks_escape_double_quotes() {
+        assert_eq!(escape_double_quotes("andrés"), "andrés");
+        assert_eq!(escape_double_quotes(r#"an"drés"#), r#"an\"drés"#);
+        assert_eq!(escape_double_quotes(r#""an"drés""#), r#"\"an\"drés\""#);
+    }
+
+    #[test]
+    fn checks_quotes_from_argument_to_be_passed_in() {
+        assert!(!argument_is_quoted(""));
+
+        assert!(!argument_is_quoted("'"));
+        assert!(!argument_is_quoted("'a"));
+        assert!(!argument_is_quoted("a"));
+        assert!(!argument_is_quoted("a'"));
+        assert!(argument_is_quoted("''"));
+
+        assert!(!argument_is_quoted(r#"""#));
+        assert!(!argument_is_quoted(r#""a"#));
+        assert!(!argument_is_quoted(r#"a"#));
+        assert!(!argument_is_quoted(r#"a""#));
+        assert!(argument_is_quoted(r#""""#));
+
+        assert!(!argument_is_quoted("'andrés"));
+        assert!(!argument_is_quoted("andrés'"));
+        assert!(!argument_is_quoted(r#""andrés"#));
+        assert!(!argument_is_quoted(r#"andrés""#));
+        assert!(argument_is_quoted("'andrés'"));
+        assert!(argument_is_quoted(r#""andrés""#));
+    }
+
+    #[test]
+    fn adds_double_quotes_to_argument_to_be_passed_in() {
+        assert_eq!(add_double_quotes("andrés"), "\"andrés\"");
+    }
+
+    #[test]
+    fn strips_quotes_from_argument_to_be_passed_in() {
+        assert_eq!(remove_quotes(""), None);
+
+        assert_eq!(remove_quotes("'"), None);
+        assert_eq!(remove_quotes("'a"), None);
+        assert_eq!(remove_quotes("a"), None);
+        assert_eq!(remove_quotes("a'"), None);
+        assert_eq!(remove_quotes("''"), Some(""));
+
+        assert_eq!(remove_quotes(r#"""#), None);
+        assert_eq!(remove_quotes(r#""a"#), None);
+        assert_eq!(remove_quotes(r#"a"#), None);
+        assert_eq!(remove_quotes(r#"a""#), None);
+        assert_eq!(remove_quotes(r#""""#), Some(""));
+
+        assert_eq!(remove_quotes("'andrés"), None);
+        assert_eq!(remove_quotes("andrés'"), None);
+        assert_eq!(remove_quotes(r#""andrés"#), None);
+        assert_eq!(remove_quotes(r#"andrés""#), None);
+        assert_eq!(remove_quotes("'andrés'"), Some("andrés"));
+        assert_eq!(remove_quotes(r#""andrés""#), Some("andrés"));
+    }
+}

crates/nu-command/src/classified/mod.rs

@@ -0,0 +1,5 @@
+mod dynamic;
+pub(crate) mod external;
+
+#[allow(unused_imports)]
+pub(crate) use dynamic::Command as DynamicCommand;

crates/nu-command/src/commands/charting/chart.rs

@@ -0,0 +1,46 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+#[derive(Clone)]
+pub struct Chart;
+
+impl WholeStreamCommand for Chart {
+    fn name(&self) -> &str {
+        "chart"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("chart")
+    }
+
+    fn usage(&self) -> &str {
+        "Displays charts."
+    }
+
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        if args.scope().get_command("chart bar").is_none() {
+            return Err(ShellError::untagged_runtime_error(
+                "nu_plugin_chart not installed.",
+            ));
+        }
+
+        Ok(ActionStream::one(Ok(ReturnSuccess::Value(
+            UntaggedValue::string(get_full_help(&Chart, args.scope())).into_value(Tag::unknown()),
+        ))))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Chart;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Chart {})
+    }
+}

crates/nu-command/src/commands/charting/histogram.rs

@@ -0,0 +1,220 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    ColumnPath, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+
+pub struct Histogram;
+
+impl WholeStreamCommand for Histogram {
+    fn name(&self) -> &str {
+        "histogram"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("histogram")
+            .named(
+                "use",
+                SyntaxShape::ColumnPath,
+                "Use data at the column path given as valuator",
+                None,
+            )
+            .rest(
+                "rest",
+                SyntaxShape::ColumnPath,
+                "column name to give the histogram's frequency column",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Creates a new table with a histogram based on the column name passed in."
+    }
+
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        histogram(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get a histogram for the types of files",
+                example: "ls | histogram type",
+                result: None,
+            },
+            Example {
+                description:
+                    "Get a histogram for the types of files, with frequency column named percentage",
+                example: "ls | histogram type percentage",
+                result: None,
+            },
+            Example {
+                description: "Get a histogram for a list of numbers",
+                example: "echo [1 2 3 1 1 1 2 2 1 1] | histogram",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub fn histogram(args: CommandArgs) -> Result<ActionStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+
+    let mut columns = args.rest::<ColumnPath>(0)?;
+    let evaluate_with = args.get_flag::<ColumnPath>("use")?.map(evaluator);
+    let values: Vec<Value> = args.input.collect();
+
+    let column_grouper = if !columns.is_empty() {
+        columns
+            .remove(0)
+            .split_last()
+            .map(|(key, _)| key.as_string().tagged(&name))
+    } else {
+        None
+    };
+
+    let frequency_column_name = if columns.is_empty() {
+        "frequency".to_string()
+    } else if let Some((key, _)) = columns[0].split_last() {
+        key.as_string()
+    } else {
+        "frequency".to_string()
+    };
+
+    let column = if let Some(ref column) = column_grouper {
+        column.clone()
+    } else {
+        "value".to_string().tagged(&name)
+    };
+
+    let results = nu_data::utils::report(
+        &UntaggedValue::table(&values).into_value(&name),
+        nu_data::utils::Operation {
+            grouper: Some(Box::new(move |_, _| Ok(String::from("frequencies")))),
+            splitter: Some(splitter(column_grouper)),
+            format: &None,
+            eval: &evaluate_with,
+            reduction: &nu_data::utils::Reduction::Count,
+        },
+        &name,
+    )?;
+
+    let labels = results.labels.y.clone();
+    let mut idx = 0;
+
+    Ok(results
+        .data
+        .table_entries()
+        .cloned()
+        .collect::<Vec<_>>()
+        .into_iter()
+        .zip(
+            results
+                .percentages
+                .table_entries()
+                .cloned()
+                .collect::<Vec<_>>()
+                .into_iter(),
+        )
+        .map(move |(counts, percentages)| {
+            let percentage = percentages
+                .table_entries()
+                .cloned()
+                .last()
+                .unwrap_or_else(|| {
+                    UntaggedValue::decimal_from_float(0.0, name.span).into_value(&name)
+                });
+            let value = counts
+                .table_entries()
+                .cloned()
+                .last()
+                .unwrap_or_else(|| UntaggedValue::int(0).into_value(&name));
+
+            let mut fact = TaggedDictBuilder::new(&name);
+            let column_value = labels
+                .get(idx)
+                .ok_or_else(|| {
+                    ShellError::labeled_error(
+                        "Unable to load group labels",
+                        "unable to load group labels",
+                        &name,
+                    )
+                })?
+                .clone();
+
+            fact.insert_value(&column.item, column_value);
+            fact.insert_untagged("count", value);
+
+            let fmt_percentage = format!(
+                "{}%",
+                // Some(2) < the number of digits
+                // true < group the digits
+                crate::commands::conversions::into::string::action(
+                    &percentage,
+                    &name,
+                    Some(2),
+                    true
+                )?
+                .as_string()?
+            );
+            fact.insert_untagged("percentage", UntaggedValue::string(fmt_percentage));
+
+            let string = "*".repeat(percentage.as_u64().map_err(|_| {
+                ShellError::labeled_error("expected a number", "expected a number", &name)
+            })? as usize);
+
+            fact.insert_untagged(&frequency_column_name, UntaggedValue::string(string));
+
+            idx += 1;
+
+            ReturnSuccess::value(fact.into_value())
+        })
+        .into_action_stream())
+}
+
+fn evaluator(by: ColumnPath) -> Box<dyn Fn(usize, &Value) -> Result<Value, ShellError> + Send> {
+    Box::new(move |_: usize, value: &Value| {
+        let path = by.clone();
+
+        let eval = nu_value_ext::get_data_by_column_path(value, &path, move |_, _, error| error);
+
+        match eval {
+            Ok(with_value) => Ok(with_value),
+            Err(reason) => Err(reason),
+        }
+    })
+}
+
+fn splitter(
+    by: Option<Tagged<String>>,
+) -> Box<dyn Fn(usize, &Value) -> Result<String, ShellError> + Send> {
+    match by {
+        Some(column) => Box::new(move |_, row: &Value| {
+            let key = &column;
+
+            match row.get_data_by_key(key.borrow_spanned()) {
+                Some(key) => nu_value_ext::as_string(&key),
+                None => Err(ShellError::labeled_error(
+                    "unknown column",
+                    "unknown column",
+                    key.tag(),
+                )),
+            }
+        }),
+        None => Box::new(move |_, row: &Value| nu_value_ext::as_string(row)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Histogram;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Histogram {})
+    }
+}

crates/nu-command/src/commands/charting/mod.rs

@@ -0,0 +1,5 @@
+mod chart;
+mod histogram;
+
+pub use chart::Chart;
+pub use histogram::Histogram;

crates/nu-command/src/commands/config/clear.rs

@@ -0,0 +1,53 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, UntaggedValue};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config clear"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config clear")
+    }
+
+    fn usage(&self) -> &str {
+        "clear the config"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        clear(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Clear the config (be careful!)",
+            example: "config clear",
+            result: None,
+        }]
+    }
+}
+
+pub fn clear(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let ctx = &args.context;
+
+    let result = if let Some(global_cfg) = &mut args.configs().lock().global_config {
+        global_cfg.vars.clear();
+        global_cfg.write()?;
+        ctx.reload_config(global_cfg)?;
+
+        let value = UntaggedValue::Row(global_cfg.vars.clone().into()).into_value(name);
+        Ok(OutputStream::one(value))
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
+    };
+
+    result
+}

crates/nu-command/src/commands/config/command.rs

@@ -0,0 +1,37 @@
+use crate::prelude::*;
+use nu_engine::CommandArgs;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, UntaggedValue};
+
+pub struct Command;
+
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "config"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config")
+    }
+
+    fn usage(&self) -> &str {
+        "Configuration management."
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let name = args.call_info.name_tag.clone();
+
+        if let Some(global_cfg) = &args.configs().lock().global_config {
+            let result = global_cfg.vars.clone();
+            let value = UntaggedValue::Row(result.into()).into_value(name);
+
+            Ok(OutputStream::one(value))
+        } else {
+            let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+                .into_value(name);
+
+            Ok(OutputStream::one(value))
+        }
+    }
+}

crates/nu-command/src/commands/config/get.rs

@@ -0,0 +1,62 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config get"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config get").required(
+            "get",
+            SyntaxShape::ColumnPath,
+            "value to get from the config",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Gets a value from the config"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        get(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the current startup commands",
+            example: "config get startup",
+            result: None,
+        }]
+    }
+}
+
+pub fn get(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let ctx = &args.context;
+
+    let column_path = args.req(0)?;
+
+    let result = if let Some(global_cfg) = &ctx.configs().lock().global_config {
+        let result = UntaggedValue::row(global_cfg.vars.clone()).into_value(&name);
+        let value = crate::commands::filters::get::get_column_path(&column_path, &result)?;
+        Ok(match value {
+            Value {
+                value: UntaggedValue::Table(list),
+                ..
+            } => OutputStream::from_stream(list.into_iter()),
+            x => OutputStream::one(x),
+        })
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
+    };
+
+    result
+}

crates/nu-command/src/commands/config/mod.rs

@@ -0,0 +1,21 @@
+pub mod clear;
+pub mod command;
+pub mod get;
+pub mod path;
+pub mod remove;
+pub mod set;
+pub mod set_into;
+
+pub use clear::SubCommand as ConfigClear;
+pub use command::Command as Config;
+pub use get::SubCommand as ConfigGet;
+pub use path::SubCommand as ConfigPath;
+pub use remove::SubCommand as ConfigRemove;
+pub use set::SubCommand as ConfigSet;
+pub use set_into::SubCommand as ConfigSetInto;
+
+use nu_errors::ShellError;
+
+pub fn err_no_global_cfg_present() -> ShellError {
+    ShellError::untagged_runtime_error("No global config found!")
+}

crates/nu-command/src/commands/config/path.rs

@@ -0,0 +1,48 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, Signature, UntaggedValue};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config path"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config path")
+    }
+
+    fn usage(&self) -> &str {
+        "return the path to the config file"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        path(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the path to the current config file",
+            example: "config path",
+            result: None,
+        }]
+    }
+}
+
+pub fn path(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+
+    if let Some(global_cfg) = &mut args.configs().lock().global_config {
+        let value = UntaggedValue::Primitive(Primitive::FilePath(global_cfg.file_path.clone()))
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
+    }
+}

crates/nu-command/src/commands/config/remove.rs

@@ -0,0 +1,70 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config remove"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config remove").required(
+            "remove",
+            SyntaxShape::Any,
+            "remove a value from the config",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Removes a value from the config"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        remove(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Remove the startup commands",
+            example: "config remove startup",
+            result: None,
+        }]
+    }
+}
+
+pub fn remove(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let ctx = &args.context;
+    let remove: Tagged<String> = args.req(0)?;
+
+    let key = remove.to_string();
+
+    let result = if let Some(global_cfg) = &mut ctx.configs().lock().global_config {
+        if global_cfg.vars.contains_key(&key) {
+            global_cfg.vars.swap_remove(&key);
+            global_cfg.write()?;
+            ctx.reload_config(global_cfg)?;
+
+            let value: Value = UntaggedValue::row(global_cfg.vars.clone()).into_value(remove.tag);
+
+            Ok(OutputStream::one(value))
+        } else {
+            Err(ShellError::labeled_error(
+                "Key does not exist in config",
+                "key",
+                remove.tag(),
+            ))
+        }
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
+    };
+
+    result
+}

crates/nu-command/src/commands/config/set.rs

@@ -0,0 +1,92 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config set"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config set")
+            .required("key", SyntaxShape::ColumnPath, "variable name to set")
+            .required("value", SyntaxShape::Any, "value to use")
+    }
+
+    fn usage(&self) -> &str {
+        "Sets a value in the config"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Set auto pivoting",
+                example: "config set pivot_mode always",
+                result: None,
+            },
+            Example {
+                description: "Set line editor options",
+                example: "config set line_editor [[edit_mode, completion_type]; [emacs circular]]",
+                result: None,
+            },
+            Example {
+                description: "Set coloring options",
+                example: "config set color_config [[header_align header_color]; [left white_bold]]",
+                result: None,
+            },
+            Example {
+                description: "Set nested options",
+                example: "config set color_config.header_color white",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub fn set(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let ctx = &args.context;
+
+    let column_path = args.req(0)?;
+    let mut value: Value = args.req(1)?;
+
+    let result = if let Some(global_cfg) = &mut ctx.configs().lock().global_config {
+        let configuration = UntaggedValue::row(global_cfg.vars.clone()).into_value(&name);
+
+        if let UntaggedValue::Table(rows) = &value.value {
+            if rows.len() == 1 && rows[0].is_row() {
+                value = rows[0].clone();
+            }
+        }
+
+        match configuration.forgiving_insert_data_at_column_path(&column_path, value) {
+            Ok(Value {
+                value: UntaggedValue::Row(changes),
+                ..
+            }) => {
+                global_cfg.vars = changes.entries;
+                global_cfg.write()?;
+                ctx.reload_config(global_cfg)?;
+
+                let value = UntaggedValue::row(global_cfg.vars.clone()).into_value(name);
+                Ok(OutputStream::one(value))
+            }
+            Ok(_) => Ok(OutputStream::empty()),
+            Err(reason) => Err(reason),
+        }
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
+    };
+
+    result
+}

crates/nu-command/src/commands/config/set_into.rs

@@ -0,0 +1,81 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config set_into"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config set_into").required(
+            "set_into",
+            SyntaxShape::String,
+            "sets a variable from values in the pipeline",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Sets a value in the config"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set_into(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Store the contents of the pipeline as a path",
+            example: "echo ['/usr/bin' '/bin'] | config set_into path",
+            result: None,
+        }]
+    }
+}
+
+pub fn set_into(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let ctx = &args.context;
+
+    let set_into: Tagged<String> = args.req(0)?;
+
+    let rows: Vec<Value> = args.input.collect();
+    let key = set_into.to_string();
+
+    let result = if let Some(global_cfg) = &mut ctx.configs().lock().global_config {
+        if rows.is_empty() {
+            return Err(ShellError::labeled_error(
+                "No values given for set_into",
+                "needs value(s) from pipeline",
+                set_into.tag(),
+            ));
+        } else if rows.len() == 1 {
+            // A single value
+            let value = &rows[0];
+
+            global_cfg.vars.insert(key, value.clone());
+        } else {
+            // Take in the pipeline as a table
+            let value = UntaggedValue::Table(rows).into_value(name.clone());
+
+            global_cfg.vars.insert(key, value);
+        }
+
+        global_cfg.write()?;
+        ctx.reload_config(global_cfg)?;
+
+        let value = UntaggedValue::row(global_cfg.vars.clone()).into_value(name);
+
+        Ok(OutputStream::one(value))
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
+    };
+
+    result
+}

crates/nu-command/src/commands/conversions/into/binary.rs

@@ -0,0 +1,185 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+use num_bigint::{BigInt, ToBigInt};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into binary"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into binary").rest(
+            "rest",
+            SyntaxShape::ColumnPath,
+            "column paths to convert to binary (for table input)",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to a binary primitive"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_binary(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "convert string to a nushell binary primitive",
+                example:
+                    "echo 'This is a string that is exactly 52 characters long.' | into binary",
+                result: Some(vec![UntaggedValue::binary(
+                    "This is a string that is exactly 52 characters long."
+                        .to_string()
+                        .as_bytes()
+                        .to_vec(),
+                )
+                .into()]),
+            },
+            Example {
+                description: "convert a number to a nushell binary primitive",
+                example: "echo 1 | into binary",
+                result: Some(vec![UntaggedValue::binary(
+                    i64::from(1).to_le_bytes().to_vec(),
+                )
+                .into()]),
+            },
+            Example {
+                description: "convert a boolean to a nushell binary primitive",
+                example: "echo $true | into binary",
+                result: Some(vec![UntaggedValue::binary(
+                    i64::from(1).to_le_bytes().to_vec(),
+                )
+                .into()]),
+            },
+            Example {
+                description: "convert a filesize to a nushell binary primitive",
+                example: "ls | where name == LICENSE | get size | into binary",
+                result: None,
+            },
+            Example {
+                description: "convert a filepath to a nushell binary primitive",
+                example: "ls | where name == LICENSE | get name | path expand | into binary",
+                result: None,
+            },
+            Example {
+                description: "convert a decimal to a nushell binary primitive",
+                example: "echo 1.234 | into binary",
+                result: Some(vec![
+                    UntaggedValue::binary(BigInt::from(1).to_bytes_le().1).into()
+                ]),
+            },
+        ]
+    }
+}
+
+fn into_binary(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+fn int_to_endian(n: i64) -> Vec<u8> {
+    if cfg!(target_endian = "little") {
+        n.to_le_bytes().to_vec()
+    } else {
+        n.to_be_bytes().to_vec()
+    }
+}
+
+fn bigint_to_endian(n: &BigInt) -> Vec<u8> {
+    if cfg!(target_endian = "little") {
+        n.to_bytes_le().1
+    } else {
+        n.to_bytes_be().1
+    }
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::binary(match prim {
+            Primitive::Binary(b) => b.to_vec(),
+            Primitive::Int(n_ref) => int_to_endian(*n_ref),
+            Primitive::BigInt(n_ref) => bigint_to_endian(n_ref),
+            Primitive::Decimal(dec) => match dec.to_bigint() {
+                Some(n) => bigint_to_endian(&n),
+                None => {
+                    return Err(ShellError::unimplemented(
+                        "failed to convert decimal to int",
+                    ));
+                }
+            },
+            Primitive::Filesize(a_filesize) => match a_filesize.to_bigint() {
+                Some(n) => bigint_to_endian(&n),
+                None => {
+                    return Err(ShellError::unimplemented(
+                        "failed to convert filesize to bigint",
+                    ));
+                }
+            },
+            Primitive::String(a_string) => a_string.as_bytes().to_vec(),
+            Primitive::Boolean(a_bool) => match a_bool {
+                false => int_to_endian(0),
+                true => int_to_endian(1),
+            },
+            Primitive::Date(a_date) => a_date.format("%c").to_string().as_bytes().to_vec(),
+            Primitive::FilePath(a_filepath) => a_filepath
+                .as_path()
+                .display()
+                .to_string()
+                .as_bytes()
+                .to_vec(),
+            _ => {
+                return Err(ShellError::unimplemented(
+                    "'into binary' for non-numeric primitives",
+                ))
+            }
+        })
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into binary COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented(
+            "'into binary' for unsupported type",
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/commands/conversions/into/column_path.rs

@@ -0,0 +1,118 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into column_path"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into column_path").rest(
+            "rest",
+            SyntaxShape::ColumnPath,
+            "values to convert to column_path",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to column path"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_filepath(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to column_path in table",
+                example: "echo [[name]; ['/dev/null'] ['C:\\Program Files'] ['../../Cargo.toml']] | into column_path name",
+                result: Some(vec![
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::column_path("/dev/null", Span::unknown()).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::column_path("C:\\Program Files", Span::unknown()).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::column_path("../../Cargo.toml", Span::unknown()).into(),
+                    })
+                    .into(),
+                ]),
+            },
+            Example {
+                description: "Convert string to column_path",
+                example: "echo 'Cargo.toml' | into column_path",
+                result: Some(vec![UntaggedValue::column_path("Cargo.toml", Span::unknown()).into()]),
+            },
+        ]
+    }
+}
+
+fn into_filepath(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::column_path(
+            match prim {
+                Primitive::String(a_string) => a_string,
+                _ => {
+                    return Err(ShellError::unimplemented(
+                        "'into column_path' for non-string primitives",
+                    ))
+                }
+            },
+            Span::unknown(),
+        )
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into column_path COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented(
+            "'into column_path' for unsupported type",
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/commands/conversions/into/command.rs

@@ -0,0 +1,39 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, UntaggedValue};
+
+pub struct Command;
+
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "into"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into")
+    }
+
+    fn usage(&self) -> &str {
+        "Apply into function."
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        Ok(OutputStream::one(
+            UntaggedValue::string(get_full_help(&Command, args.scope())).into_value(Tag::unknown()),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Command;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Command {})
+    }
+}

crates/nu-command/src/commands/conversions/into/filepath.rs

@@ -0,0 +1,127 @@
+use std::path::PathBuf;
+
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into path"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into path").rest(
+            "rest",
+            SyntaxShape::ColumnPath,
+            "column paths to convert to filepath (for table input)",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to filepath"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_filepath(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to filepath in table",
+                example: "echo [[name]; ['/dev/null'] ['C:\\Program Files'] ['../../Cargo.toml']] | into path name",
+                result: Some(vec![
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::filepath("/dev/null").into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::filepath("C:\\Program Files").into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::filepath("../../Cargo.toml").into(),
+                    })
+                    .into(),
+                ]),
+            },
+            Example {
+                description: "Convert string to filepath",
+                example: "echo 'Cargo.toml' | into path",
+                result: Some(vec![UntaggedValue::filepath("Cargo.toml").into()]),
+            },
+        ]
+    }
+}
+
+fn into_filepath(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::filepath(match prim {
+            Primitive::String(a_string) => match filepath_from_string(a_string, &tag) {
+                Ok(n) => n,
+                Err(e) => {
+                    return Err(e);
+                }
+            },
+            Primitive::FilePath(a_filepath) => a_filepath.clone(),
+            _ => {
+                return Err(ShellError::unimplemented(
+                    "'into path' for non-string primitives",
+                ))
+            }
+        })
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into path COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented(
+            "'into path' for unsupported type",
+        )),
+    }
+}
+
+fn filepath_from_string(a_string: &str, _tag: &Tag) -> Result<PathBuf, ShellError> {
+    Ok(PathBuf::from(a_string))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/commands/conversions/into/filesize.rs

@@ -0,0 +1,182 @@
+use std::convert::TryInto;
+
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+use num_bigint::ToBigInt;
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into filesize"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into filesize").rest(
+            "rest",
+            SyntaxShape::ColumnPath,
+            "column paths to convert to filesize (for table input)",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to filesize"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_filesize(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to filesize in table",
+                example: "echo [[bytes]; ['5'] [3.2] [4] [2kb]] | into filesize bytes",
+                result: Some(vec![
+                    UntaggedValue::row(indexmap! {
+                        "bytes".to_string() => UntaggedValue::filesize(5).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "bytes".to_string() => UntaggedValue::filesize(3).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "bytes".to_string() => UntaggedValue::filesize(4).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "bytes".to_string() => UntaggedValue::filesize(2000).into(),
+                    })
+                    .into(),
+                ]),
+            },
+            Example {
+                description: "Convert string to filesize",
+                example: "echo '2' | into filesize",
+                result: Some(vec![UntaggedValue::filesize(2).into()]),
+            },
+            Example {
+                description: "Convert decimal to filesize",
+                example: "echo 8.3 | into filesize",
+                result: Some(vec![UntaggedValue::filesize(8).into()]),
+            },
+            Example {
+                description: "Convert int to filesize",
+                example: "echo 5 | into filesize",
+                result: Some(vec![UntaggedValue::filesize(5).into()]),
+            },
+            Example {
+                description: "Convert file size to filesize",
+                example: "echo 4KB | into filesize",
+                result: Some(vec![UntaggedValue::filesize(4000).into()]),
+            },
+        ]
+    }
+}
+
+fn into_filesize(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::filesize(match prim {
+            Primitive::String(a_string) => match int_from_string(a_string.trim(), &tag) {
+                Ok(n) => n,
+                Err(e) => {
+                    return Err(e);
+                }
+            },
+            Primitive::Decimal(dec) => match dec.to_bigint() {
+                Some(n) => match n.to_u64() {
+                    Some(i) => i,
+                    None => {
+                        return Err(ShellError::unimplemented(
+                            "failed to convert decimal to filesize",
+                        ));
+                    }
+                },
+                None => {
+                    return Err(ShellError::unimplemented(
+                        "failed to convert decimal to filesize",
+                    ));
+                }
+            },
+            Primitive::Int(n_ref) => (*n_ref).try_into().map_err(|_| {
+                ShellError::unimplemented("cannot convert negative integer to filesize")
+            })?,
+            Primitive::Filesize(a_filesize) => *a_filesize,
+            _ => {
+                return Err(ShellError::unimplemented(
+                    "'into filesize' for non-numeric primitives",
+                ))
+            }
+        })
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into filesize COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented(
+            "'into filesize' for unsupported type",
+        )),
+    }
+}
+
+fn int_from_string(a_string: &str, tag: &Tag) -> Result<u64, ShellError> {
+    match a_string.parse::<u64>() {
+        Ok(n) => Ok(n),
+        Err(_) => match a_string.parse::<f64>() {
+            Ok(f) => match f.to_u64() {
+                Some(i) => Ok(i),
+                None => Err(ShellError::labeled_error(
+                    "Could not convert string value to filesize",
+                    "original value",
+                    tag.clone(),
+                )),
+            },
+            Err(_) => Err(ShellError::labeled_error(
+                "Could not convert string value to filesize",
+                "original value",
+                tag.clone(),
+            )),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/commands/conversions/into/int.rs

@@ -0,0 +1,198 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+use num_bigint::ToBigInt;
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into int"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into int").rest(
+            "rest",
+            SyntaxShape::ColumnPath,
+            "column paths to convert to int (for table input)",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to integer"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_int(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to integer in table",
+                example: "echo [[num]; ['-5'] [4] [1.5]] | into int num",
+                result: Some(vec![
+                    UntaggedValue::row(indexmap! {
+                        "num".to_string() => UntaggedValue::int(-5).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "num".to_string() => UntaggedValue::int(4).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "num".to_string() => UntaggedValue::int(1).into(),
+                    })
+                    .into(),
+                ]),
+            },
+            Example {
+                description: "Convert string to integer",
+                example: "echo '2' | into int",
+                result: Some(vec![UntaggedValue::int(2).into()]),
+            },
+            Example {
+                description: "Convert decimal to integer",
+                example: "echo 5.9 | into int",
+                result: Some(vec![UntaggedValue::int(5).into()]),
+            },
+            Example {
+                description: "Convert decimal string to integer",
+                example: "echo '5.9' | into int",
+                result: Some(vec![UntaggedValue::int(5).into()]),
+            },
+            Example {
+                description: "Convert file size to integer",
+                example: "echo 4KB | into int",
+                result: Some(vec![UntaggedValue::int(4000).into()]),
+            },
+            Example {
+                description: "Convert bool to integer",
+                example: "echo $false $true | into int",
+                result: Some(vec![
+                    UntaggedValue::int(0).into(),
+                    UntaggedValue::int(1).into(),
+                ]),
+            },
+        ]
+    }
+}
+
+fn into_int(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::int(match prim {
+            Primitive::String(a_string) => match int_from_string(a_string, &tag) {
+                Ok(n) => n,
+                Err(e) => {
+                    return Err(e);
+                }
+            },
+            Primitive::Decimal(dec) => match dec.to_bigint() {
+                Some(n) => match n.to_i64() {
+                    Some(i) => i,
+                    None => {
+                        return Err(ShellError::unimplemented(
+                            "failed to convert decimal to int",
+                        ));
+                    }
+                },
+                None => {
+                    return Err(ShellError::unimplemented(
+                        "failed to convert decimal to int",
+                    ));
+                }
+            },
+            Primitive::Int(n_ref) => *n_ref,
+            Primitive::Boolean(a_bool) => match a_bool {
+                false => 0,
+                true => 1,
+            },
+            Primitive::Filesize(a_filesize) => match a_filesize.to_bigint() {
+                Some(n) => match n.to_i64() {
+                    Some(i) => i,
+                    None => {
+                        return Err(ShellError::unimplemented(
+                            "failed to convert filesize to bigint",
+                        ));
+                    }
+                },
+                None => {
+                    return Err(ShellError::unimplemented(
+                        "failed to convert filesize to bigint",
+                    ));
+                }
+            },
+            _ => {
+                return Err(ShellError::unimplemented(
+                    "'into int' for non-numeric primitives",
+                ))
+            }
+        })
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into int COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented("'into int' for unsupported type")),
+    }
+}
+
+fn int_from_string(a_string: &str, tag: &Tag) -> Result<i64, ShellError> {
+    match a_string.parse::<i64>() {
+        Ok(n) => Ok(n),
+        Err(_) => match a_string.parse::<f64>() {
+            Ok(f) => match f.to_i64() {
+                Some(i) => Ok(i),
+                None => Err(ShellError::labeled_error(
+                    "Could not convert string value to int",
+                    "original value",
+                    tag.clone(),
+                )),
+            },
+            Err(_) => Err(ShellError::labeled_error(
+                "Could not convert string value to int",
+                "original value",
+                tag.clone(),
+            )),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/commands/conversions/into/mod.rs

@@ -0,0 +1,15 @@
+mod binary;
+mod column_path;
+mod command;
+mod filepath;
+mod filesize;
+mod int;
+pub mod string;
+
+pub use self::filesize::SubCommand as IntoFilesize;
+pub use binary::SubCommand as IntoBinary;
+pub use column_path::SubCommand as IntoColumnPath;
+pub use command::Command as Into;
+pub use filepath::SubCommand as IntoFilepath;
+pub use int::SubCommand as IntoInt;
+pub use string::SubCommand as IntoString;

crates/nu-command/src/commands/conversions/into/string.rs

@@ -0,0 +1,279 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+use num_bigint::{BigInt, BigUint, ToBigInt};
+// TODO num_format::SystemLocale once platform-specific dependencies are stable (see Cargo.toml)
+use nu_data::base::shape::InlineShape;
+use num_format::Locale;
+use num_traits::{Pow, Signed};
+use std::iter;
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into string"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into string")
+            .rest(
+                "rest",
+                SyntaxShape::ColumnPath,
+                "column paths to convert to string (for table input)",
+            )
+            .named(
+                "decimals",
+                SyntaxShape::Int,
+                "decimal digits to which to round",
+                Some('d'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to string"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_string(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "convert decimal to string and round to nearest integer",
+                example: "echo 1.7 | into string -d 0",
+                result: Some(vec![UntaggedValue::string("2").into_untagged_value()]),
+            },
+            Example {
+                description: "convert decimal to string",
+                example: "echo 4.3 | into string",
+                result: Some(vec![UntaggedValue::string("4.3").into_untagged_value()]),
+            },
+            Example {
+                description: "convert string to string",
+                example: "echo '1234' | into string",
+                result: Some(vec![UntaggedValue::string("1234").into_untagged_value()]),
+            },
+            Example {
+                description: "convert boolean to string",
+                example: "echo $true | into string",
+                result: Some(vec![UntaggedValue::string("true").into_untagged_value()]),
+            },
+            Example {
+                description: "convert date to string",
+                example: "date now | into string",
+                result: None,
+            },
+            Example {
+                description: "convert filepath to string",
+                example: "ls Cargo.toml | get name | into string",
+                result: None,
+            },
+            Example {
+                description: "convert filesize to string",
+                example: "ls Cargo.toml | get size | into string",
+                result: None,
+            },
+        ]
+    }
+}
+
+fn into_string(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let decimals: Option<Tagged<u64>> = args.get_flag("decimals")?;
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    let digits = decimals.as_ref().map(|tagged| tagged.item);
+    let group_digits = false;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag(), digits, group_digits)
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag(), digits, group_digits)),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+pub fn action(
+    input: &Value,
+    tag: impl Into<Tag>,
+    digits: Option<u64>,
+    group_digits: bool,
+) -> Result<Value, ShellError> {
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::string(match prim {
+            Primitive::Int(int) => {
+                if group_digits {
+                    format_int(*int) // int.to_formatted_string(*locale)
+                } else {
+                    int.to_string()
+                }
+            }
+            Primitive::BigInt(int) => {
+                if group_digits {
+                    format_bigint(int) // int.to_formatted_string(*locale)
+                } else {
+                    int.to_string()
+                }
+            }
+            Primitive::Decimal(dec) => format_decimal(dec.clone(), digits, group_digits),
+            Primitive::String(a_string) => a_string.to_string(),
+            Primitive::Boolean(a_bool) => a_bool.to_string(),
+            Primitive::Date(a_date) => a_date.format("%c").to_string(),
+            Primitive::FilePath(a_filepath) => a_filepath.as_path().display().to_string(),
+            Primitive::Filesize(a_filesize) => {
+                let byte_string = InlineShape::format_bytes(*a_filesize, None);
+                byte_string.1
+            }
+            Primitive::Nothing => "nothing".to_string(),
+            _ => {
+                return Err(ShellError::unimplemented(&format!(
+                    "into string for primitive: {:?}",
+                    prim
+                )))
+            }
+        })
+        .into_value(tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column to use 'into string'",
+            "found table",
+            input.tag.clone(),
+        )),
+        UntaggedValue::Table(_) => Err(ShellError::unimplemented("into string for table")),
+        _ => Err(ShellError::unimplemented("into string for non-primitive")),
+    }
+}
+
+fn format_int(int: i64) -> String {
+    int.to_string()
+
+    // TODO once platform-specific dependencies are stable (see Cargo.toml)
+    // #[cfg(windows)]
+    // {
+    //     int.to_formatted_string(&Locale::en)
+    // }
+    // #[cfg(not(windows))]
+    // {
+    //     match SystemLocale::default() {
+    //         Ok(locale) => int.to_formatted_string(&locale),
+    //         Err(_) => int.to_formatted_string(&Locale::en),
+    //     }
+    // }
+}
+
+fn format_bigint(int: &BigInt) -> String {
+    int.to_string()
+
+    // TODO once platform-specific dependencies are stable (see Cargo.toml)
+    // #[cfg(windows)]
+    // {
+    //     int.to_formatted_string(&Locale::en)
+    // }
+    // #[cfg(not(windows))]
+    // {
+    //     match SystemLocale::default() {
+    //         Ok(locale) => int.to_formatted_string(&locale),
+    //         Err(_) => int.to_formatted_string(&Locale::en),
+    //     }
+    // }
+}
+
+fn format_decimal(mut decimal: BigDecimal, digits: Option<u64>, group_digits: bool) -> String {
+    if let Some(n) = digits {
+        decimal = round_decimal(&decimal, n)
+    }
+
+    if decimal.is_integer() && (digits.is_none() || digits == Some(0)) {
+        let int = decimal
+            .to_bigint()
+            .expect("integer BigDecimal should convert to BigInt");
+        return if group_digits {
+            int.to_string()
+        } else {
+            format_bigint(&int)
+        };
+    }
+
+    let (int, exp) = decimal.as_bigint_and_exponent();
+    let factor = BigInt::from(10).pow(BigUint::from(exp as u64)); // exp > 0 for non-int decimal
+    let int_part = &int / &factor;
+    let dec_part = (&int % &factor)
+        .abs()
+        .to_biguint()
+        .expect("BigInt::abs should always produce positive signed BigInt and thus BigUInt")
+        .to_str_radix(10);
+
+    let dec_str = if let Some(n) = digits {
+        dec_part
+            .chars()
+            .chain(iter::repeat('0'))
+            .take(n as usize)
+            .collect()
+    } else {
+        String::from(dec_part.trim_end_matches('0'))
+    };
+
+    let format_default_loc = |int_part: BigInt| {
+        let loc = Locale::en;
+        //TODO: when num_format is available for recent bigint, replace this with the locale-based format
+        let (int_str, sep) = (int_part.to_string(), String::from(loc.decimal()));
+
+        format!("{}{}{}", int_str, sep, dec_str)
+    };
+
+    format_default_loc(int_part)
+
+    // TODO once platform-specific dependencies are stable (see Cargo.toml)
+    // #[cfg(windows)]
+    // {
+    //     format_default_loc(int_part)
+    // }
+    // #[cfg(not(windows))]
+    // {
+    //     match SystemLocale::default() {
+    //         Ok(sys_loc) => {
+    //             let int_str = int_part.to_formatted_string(&sys_loc);
+    //             let sep = String::from(sys_loc.decimal());
+    //             format!("{}{}{}", int_str, sep, dec_str)
+    //         }
+    //         Err(_) => format_default_loc(int_part),
+    //     }
+    // }
+}
+
+fn round_decimal(decimal: &BigDecimal, mut digits: u64) -> BigDecimal {
+    let mut mag = decimal.clone();
+    while mag >= BigDecimal::from(1) {
+        mag = mag / 10;
+        digits += 1;
+    }
+
+    decimal.with_prec(digits)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::SubCommand;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/commands/conversions/mod.rs

@@ -0,0 +1,3 @@
+pub(crate) mod into;
+
+pub use into::*;

crates/nu-command/src/commands/core_commands/alias.rs

@@ -0,0 +1,52 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
+
+pub struct Alias;
+
+impl WholeStreamCommand for Alias {
+    fn name(&self) -> &str {
+        "alias"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("alias")
+            .required("name", SyntaxShape::String, "the name of the alias")
+            .required("equals", SyntaxShape::String, "the equals sign")
+            .rest("rest", SyntaxShape::Any, "the expansion for the alias")
+    }
+
+    fn usage(&self) -> &str {
+        "Alias a command to an expansion."
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        alias(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Alias ll to ls -l",
+            example: "alias ll = ls -l",
+            result: None,
+        }]
+    }
+}
+
+pub fn alias(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    // TODO: is there a better way of checking whether no arguments were passed?
+    if args.nth(0).is_none() {
+        let aliases = UntaggedValue::string(
+            &args
+                .scope()
+                .get_aliases()
+                .iter()
+                .map(|val| format!("{} = '{}'", val.0, val.1.iter().map(|x| &x.item).join(" ")))
+                .join("\n"),
+        );
+        return Ok(OutputStream::one(aliases));
+    }
+    Ok(OutputStream::empty())
+}

crates/nu-command/src/commands/core_commands/debug.rs

@@ -0,0 +1,54 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct Debug;
+
+impl WholeStreamCommand for Debug {
+    fn name(&self) -> &str {
+        "debug"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("debug").switch("raw", "Prints the raw value representation.", Some('r'))
+    }
+
+    fn usage(&self) -> &str {
+        "Print the Rust debug representation of the values."
+    }
+
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        debug_value(args)
+    }
+}
+
+fn debug_value(args: CommandArgs) -> Result<ActionStream, ShellError> {
+    let raw = args.has_flag("raw");
+    let input = args.input;
+
+    Ok(input
+        .map(move |v| {
+            if raw {
+                ReturnSuccess::value(
+                    UntaggedValue::string(format!("{:#?}", v)).into_untagged_value(),
+                )
+            } else {
+                ReturnSuccess::debug_value(v)
+            }
+        })
+        .into_action_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Debug;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Debug {})
+    }
+}

crates/nu-command/src/commands/core_commands/def.rs

@@ -0,0 +1,47 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+
+use nu_errors::ShellError;
+use nu_protocol::{hir::CapturedBlock, Signature, SyntaxShape, Value};
+use nu_source::Tagged;
+
+pub struct Def;
+
+#[derive(Deserialize)]
+pub struct DefArgs {
+    pub name: Tagged<String>,
+    pub args: Tagged<Vec<Value>>,
+    pub block: CapturedBlock,
+}
+
+impl WholeStreamCommand for Def {
+    fn name(&self) -> &str {
+        "def"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("def")
+            .required("name", SyntaxShape::String, "the name of the command")
+            .required(
+                "params",
+                SyntaxShape::Table,
+                "the parameters of the command",
+            )
+            .required("block", SyntaxShape::Block, "the body of the command")
+    }
+
+    fn usage(&self) -> &str {
+        "Create a command and set it to a definition."
+    }
+
+    fn run_with_actions(&self, _args: CommandArgs) -> Result<ActionStream, ShellError> {
+        // Currently, we don't do anything here because we should have already
+        // installed the definition as we entered the scope
+        // We just create a command so that we can get proper coloring
+        Ok(ActionStream::empty())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![]
+    }
+}

crates/nu-command/src/commands/core_commands/describe.rs

@@ -0,0 +1,53 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct Describe;
+
+#[derive(Deserialize)]
+pub struct DescribeArgs {}
+
+impl WholeStreamCommand for Describe {
+    fn name(&self) -> &str {
+        "describe"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("describe")
+    }
+
+    fn usage(&self) -> &str {
+        "Describes the objects in the stream."
+    }
+
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        describe(args)
+    }
+}
+
+pub fn describe(args: CommandArgs) -> Result<ActionStream, ShellError> {
+    Ok(args
+        .input
+        .map(|row| {
+            let name = value::plain_type(&row, 100);
+            ReturnSuccess::value(
+                UntaggedValue::string(name).into_value(Tag::unknown_anchor(row.tag.span)),
+            )
+        })
+        .into_action_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Describe;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Describe {})
+    }
+}

crates/nu-command/src/commands/core_commands/do_.rs

@@ -0,0 +1,141 @@
+use crate::prelude::*;
+use nu_engine::run_block;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::CapturedBlock, hir::ExternalRedirection, Signature, SyntaxShape, UntaggedValue, Value,
+};
+
+pub struct Do;
+
+struct DoArgs {
+    block: CapturedBlock,
+    ignore_errors: bool,
+    rest: Vec<Value>,
+}
+
+impl WholeStreamCommand for Do {
+    fn name(&self) -> &str {
+        "do"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("do")
+            .required("block", SyntaxShape::Block, "the block to run ")
+            .switch(
+                "ignore-errors",
+                "ignore errors as the block runs",
+                Some('i'),
+            )
+            .rest("rest", SyntaxShape::Any, "the parameter(s) for the block")
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block, optionally ignoring errors."
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        do_(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Run the block",
+                example: r#"do { echo hello }"#,
+                result: Some(vec![Value::from("hello")]),
+            },
+            Example {
+                description: "Run the block and ignore errors",
+                example: r#"do -i { thisisnotarealcommand }"#,
+                result: Some(vec![]),
+            },
+            Example {
+                description: "Run the block with a parameter",
+                example: r#"do { |x| $x + 100 } 55"#,
+                result: Some(vec![UntaggedValue::int(155).into()]),
+            },
+        ]
+    }
+}
+
+fn do_(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let external_redirection = args.call_info.args.external_redirection;
+
+    let context = args.context().clone();
+    let do_args = DoArgs {
+        block: args.req(0)?,
+        ignore_errors: args.has_flag("ignore-errors"),
+        rest: args.rest(1)?,
+    };
+
+    let block_redirection = match external_redirection {
+        ExternalRedirection::None => {
+            if do_args.ignore_errors {
+                ExternalRedirection::Stderr
+            } else {
+                ExternalRedirection::None
+            }
+        }
+        ExternalRedirection::Stdout => {
+            if do_args.ignore_errors {
+                ExternalRedirection::StdoutAndStderr
+            } else {
+                ExternalRedirection::Stdout
+            }
+        }
+        x => x,
+    };
+
+    context.scope.enter_scope();
+
+    context.scope.add_vars(&do_args.block.captured.entries);
+
+    for (param, value) in do_args
+        .block
+        .block
+        .params
+        .positional
+        .iter()
+        .zip(do_args.rest)
+    {
+        context.scope.add_var(param.0.name(), value.clone());
+    }
+
+    let result = run_block(
+        &do_args.block.block,
+        &context,
+        args.input,
+        block_redirection,
+    );
+    context.scope.exit_scope();
+
+    if do_args.ignore_errors {
+        // To properly ignore errors we need to redirect stderr, consume it, and remove
+        // any errors we see in the process.
+
+        match result {
+            Ok(mut stream) => {
+                let output = stream.drain_vec();
+                context.clear_errors();
+                Ok(output.into_iter().into_output_stream())
+            }
+            Err(_) => Ok(OutputStream::empty()),
+        }
+    } else {
+        result.map(|x| x.into_output_stream())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Do;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Do {})
+    }
+}

crates/nu-command/src/commands/core_commands/echo.rs

@@ -0,0 +1,207 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::hir::Operator;
+use nu_protocol::{Primitive, Range, RangeInclusion, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct Echo;
+
+impl WholeStreamCommand for Echo {
+    fn name(&self) -> &str {
+        "echo"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("echo").rest("rest", SyntaxShape::Any, "the values to echo")
+    }
+
+    fn usage(&self) -> &str {
+        "Echo the arguments back to the user."
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<InputStream, ShellError> {
+        echo(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Put a hello message in the pipeline",
+                example: "echo 'hello'",
+                result: Some(vec![Value::from("hello")]),
+            },
+            Example {
+                description: "Print the value of the special '$nu' variable",
+                example: "echo $nu",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub fn expand_value_to_stream(v: Value) -> InputStream {
+    match v {
+        Value {
+            value: UntaggedValue::Table(table),
+            ..
+        } => InputStream::from_stream(table.into_iter()),
+        Value {
+            value: UntaggedValue::Primitive(Primitive::Range(range)),
+            tag,
+        } => InputStream::from_stream(RangeIterator::new(*range, tag)),
+        x => InputStream::one(x),
+    }
+}
+
+fn echo(args: CommandArgs) -> Result<InputStream, ShellError> {
+    let rest: Vec<Value> = args.rest(0)?;
+
+    let stream = rest.into_iter().map(|i| match i.as_string() {
+        Ok(s) => InputStream::one(UntaggedValue::string(s).into_value(i.tag)),
+        _ => expand_value_to_stream(i),
+    });
+
+    Ok(InputStream::from_stream(stream.flatten()))
+}
+
+struct RangeIterator {
+    curr: UntaggedValue,
+    end: UntaggedValue,
+    tag: Tag,
+    is_end_inclusive: bool,
+    moves_up: bool,
+    one: UntaggedValue,
+    negative_one: UntaggedValue,
+    done: bool,
+}
+
+impl RangeIterator {
+    pub fn new(range: Range, tag: Tag) -> RangeIterator {
+        let start = match range.from.0.item {
+            Primitive::Nothing => Primitive::Int(0.into()),
+            x => x,
+        };
+
+        let end = match range.to.0.item {
+            Primitive::Nothing => Primitive::Int(i64::MAX),
+            x => x,
+        };
+
+        RangeIterator {
+            moves_up: start <= end,
+            curr: UntaggedValue::Primitive(start),
+            end: UntaggedValue::Primitive(end),
+            tag,
+            is_end_inclusive: matches!(range.to.1, RangeInclusion::Inclusive),
+            one: UntaggedValue::int(1),
+            negative_one: UntaggedValue::int(-1),
+            done: false,
+        }
+    }
+}
+
+impl Iterator for RangeIterator {
+    type Item = Value;
+    fn next(&mut self) -> Option<Self::Item> {
+        use std::cmp::Ordering;
+        if self.done {
+            return None;
+        }
+
+        let ordering = if self.end == UntaggedValue::Primitive(Primitive::Nothing) {
+            Ordering::Less
+        } else {
+            match (&self.curr, &self.end) {
+                (
+                    UntaggedValue::Primitive(Primitive::Int(x)),
+                    UntaggedValue::Primitive(Primitive::Int(y)),
+                ) => x.cmp(y),
+                (
+                    UntaggedValue::Primitive(Primitive::Decimal(x)),
+                    UntaggedValue::Primitive(Primitive::Decimal(y)),
+                ) => x.cmp(y),
+                (
+                    UntaggedValue::Primitive(Primitive::Decimal(x)),
+                    UntaggedValue::Primitive(Primitive::Int(y)),
+                ) => x.cmp(&(BigDecimal::from(*y))),
+                (
+                    UntaggedValue::Primitive(Primitive::Int(x)),
+                    UntaggedValue::Primitive(Primitive::Decimal(y)),
+                ) => (BigDecimal::from(*x)).cmp(y),
+                _ => {
+                    self.done = true;
+                    return Some(
+                        UntaggedValue::Error(ShellError::labeled_error(
+                            "Cannot create range",
+                            "unsupported range",
+                            self.tag.span,
+                        ))
+                        .into_untagged_value(),
+                    );
+                }
+            }
+        };
+
+        if self.moves_up
+            && (ordering == Ordering::Less || self.is_end_inclusive && ordering == Ordering::Equal)
+        {
+            let next_value = nu_data::value::compute_values(Operator::Plus, &self.curr, &self.one);
+
+            let mut next = match next_value {
+                Ok(result) => result,
+
+                Err((left_type, right_type)) => {
+                    self.done = true;
+                    return Some(
+                        UntaggedValue::Error(ShellError::coerce_error(
+                            left_type.spanned(self.tag.span),
+                            right_type.spanned(self.tag.span),
+                        ))
+                        .into_untagged_value(),
+                    );
+                }
+            };
+            std::mem::swap(&mut self.curr, &mut next);
+
+            Some(next.into_value(self.tag.clone()))
+        } else if !self.moves_up
+            && (ordering == Ordering::Greater
+                || self.is_end_inclusive && ordering == Ordering::Equal)
+        {
+            let next_value =
+                nu_data::value::compute_values(Operator::Plus, &self.curr, &self.negative_one);
+
+            let mut next = match next_value {
+                Ok(result) => result,
+                Err((left_type, right_type)) => {
+                    self.done = true;
+                    return Some(
+                        UntaggedValue::Error(ShellError::coerce_error(
+                            left_type.spanned(self.tag.span),
+                            right_type.spanned(self.tag.span),
+                        ))
+                        .into_untagged_value(),
+                    );
+                }
+            };
+            std::mem::swap(&mut self.curr, &mut next);
+
+            Some(next.into_value(self.tag.clone()))
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Echo;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Echo {})
+    }
+}

crates/nu-command/src/commands/core_commands/error/make.rs

@@ -0,0 +1,109 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, Signature, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "error make"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("error make")
+    }
+
+    fn usage(&self) -> &str {
+        "Create an error."
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let input = args.input;
+
+        Ok(input
+            .map(|value| {
+                make_error(&value)
+                    .map(|err| UntaggedValue::Error(err).into_value(value.tag()))
+                    .unwrap_or_else(|| {
+                        UntaggedValue::Error(ShellError::untagged_runtime_error(
+                            "Creating error value not supported.",
+                        ))
+                        .into_value(value.tag())
+                    })
+            })
+            .into_output_stream())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Creates a labeled error",
+            example: r#"[
+  [          msg,                 labels,                      span];
+  ["The message", "Helpful message here", ([[start, end]; [0, 141]])]
+] | error make"#,
+            result: None,
+        }]
+    }
+}
+
+fn make_error(value: &Value) -> Option<ShellError> {
+    if let Value {
+        value: UntaggedValue::Row(dict),
+        ..
+    } = value
+    {
+        let msg = dict.get_data_by_key("msg".spanned_unknown());
+
+        let labels =
+            dict.get_data_by_key("labels".spanned_unknown())
+                .and_then(|table| match &table.value {
+                    UntaggedValue::Table(_) => table
+                        .table_entries()
+                        .map(|value| value.as_string().ok())
+                        .collect(),
+                    UntaggedValue::Primitive(Primitive::String(label)) => {
+                        Some(vec![label.to_string()])
+                    }
+                    _ => None,
+                });
+
+        let _anchor = dict.get_data_by_key("tag".spanned_unknown());
+        let span = dict.get_data_by_key("span".spanned_unknown());
+
+        if msg.is_none() || labels.is_none() || span.is_none() {
+            return None;
+        }
+
+        let msg = msg.and_then(|msg| msg.as_string().ok());
+
+        if let Some(labels) = labels {
+            if labels.is_empty() {
+                return None;
+            }
+
+            return Some(ShellError::labeled_error(
+                msg.expect("Message will always be present."),
+                &labels[0],
+                span.map(|data| match data {
+                    Value {
+                        value: UntaggedValue::Row(vals),
+                        ..
+                    } => match (vals.entries.get("start"), vals.entries.get("end")) {
+                        (Some(start), Some(end)) => {
+                            let start = start.as_usize().ok().unwrap_or(0);
+                            let end = end.as_usize().ok().unwrap_or(0);
+
+                            Span::new(start, end)
+                        }
+                        (_, _) => Span::unknown(),
+                    },
+                    _ => Span::unknown(),
+                })
+                .unwrap_or_else(Span::unknown),
+            ));
+        }
+    }
+
+    None
+}

crates/nu-command/src/commands/core_commands/error/mod.rs

@@ -0,0 +1,3 @@
+mod make;
+
+pub use make::SubCommand as ErrorMake;

crates/nu-command/src/commands/core_commands/find.rs

@@ -0,0 +1,110 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Dictionary, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct Find;
+
+impl WholeStreamCommand for Find {
+    fn name(&self) -> &str {
+        "find"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("find").rest("rest", SyntaxShape::String, "search term")
+    }
+
+    fn usage(&self) -> &str {
+        "Find text in the output of a previous command"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        find(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Search pipeline output for multiple terms",
+                example: r#"ls | find toml md sh"#,
+                result: None,
+            },
+            Example {
+                description: "Search strings for term(s)",
+                example: r#"echo Cargo.toml | find toml"#,
+                result: Some(vec![Value::from("Cargo.toml")]),
+            },
+            Example {
+                description: "Search a number list for term(s)",
+                example: r#"[1 2 3 4 5] | find 5"#,
+                result: Some(vec![UntaggedValue::int(5).into()]),
+            },
+            Example {
+                description: "Search string list for term(s)",
+                example: r#"[moe larry curly] | find l"#,
+                result: Some(vec![Value::from("larry"), Value::from("curly")]),
+            },
+        ]
+    }
+}
+
+fn row_contains(row: &Dictionary, search_terms: Vec<String>) -> bool {
+    for term in search_terms {
+        for (k, v) in &row.entries {
+            let key = k.to_string().trim().to_lowercase();
+            let value = v.convert_to_string().trim().to_lowercase();
+            if key.contains(&term) || value.contains(&term) {
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
+fn find(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let rest: Vec<Value> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .filter(move |row| match &row.value {
+            UntaggedValue::Row(row) => {
+                let sterms: Vec<String> = rest
+                    .iter()
+                    .map(|t| t.convert_to_string().trim().to_lowercase())
+                    .collect();
+                row_contains(row, sterms)
+            }
+            UntaggedValue::Primitive(_p) => {
+                // eprint!("prim {}", p.type_name());
+                let sterms: Vec<String> = rest
+                    .iter()
+                    .map(|t| t.convert_to_string().trim().to_lowercase())
+                    .collect();
+
+                let prim_string = &row.convert_to_string().trim().to_lowercase();
+                for term in sterms {
+                    if prim_string.contains(&term) {
+                        return true;
+                    }
+                }
+
+                false
+            }
+            _ => false,
+        })
+        .into_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Find;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Find {})
+    }
+}

crates/nu-command/src/commands/core_commands/help.rs

@@ -0,0 +1,353 @@
+use crate::prelude::*;
+use crate::TaggedListBuilder;
+use nu_engine::{documentation::generate_docs, Command, WholeStreamCommand};
+use nu_errors::ShellError;
+use nu_protocol::{
+    Dictionary, NamedType, PositionalType, ReturnSuccess, Signature, SyntaxShape,
+    TaggedDictBuilder, UntaggedValue, Value,
+};
+use nu_source::{SpannedItem, Tag, Tagged};
+use nu_value_ext::ValueExt;
+
+pub struct Help;
+
+impl WholeStreamCommand for Help {
+    fn name(&self) -> &str {
+        "help"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("help")
+            .rest(
+                "rest",
+                SyntaxShape::String,
+                "the name of command to get help on",
+            )
+            .named(
+                "find",
+                SyntaxShape::String,
+                "string to find in command usage",
+                Some('f'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Display help information about commands."
+    }
+
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        help(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "show all commands and sub-commands",
+                example: "help commands",
+                result: None,
+            },
+            Example {
+                description: "generate documentation",
+                example: "help generate_docs",
+                result: None,
+            },
+            Example {
+                description: "show help for single command",
+                example: "help match",
+                result: None,
+            },
+            Example {
+                description: "show help for single sub-command",
+                example: "help str lpad",
+                result: None,
+            },
+            Example {
+                description: "search for string in command usage",
+                example: "help --find char",
+                result: None,
+            },
+        ]
+    }
+}
+
+fn help(args: CommandArgs) -> Result<ActionStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let scope = args.scope().clone();
+    let find: Option<Tagged<String>> = args.get_flag("find")?;
+    let rest: Vec<Tagged<String>> = args.rest(0)?;
+
+    if let Some(f) = find {
+        let search_string = f.item;
+        let full_commands = scope.get_commands_info();
+        let mut found_cmds_vec = Vec::new();
+
+        for (key, cmd) in full_commands {
+            let mut indexmap = IndexMap::new();
+
+            let c = cmd.usage().to_string();
+            let e = cmd.extra_usage().to_string();
+            if key.to_lowercase().contains(&search_string)
+                || c.to_lowercase().contains(&search_string)
+                || e.to_lowercase().contains(&search_string)
+            {
+                indexmap.insert(
+                    "name".to_string(),
+                    UntaggedValue::string(key).into_value(&name),
+                );
+
+                indexmap.insert(
+                    "usage".to_string(),
+                    UntaggedValue::string(cmd.usage().to_string()).into_value(&name),
+                );
+
+                indexmap.insert(
+                    "extra_usage".to_string(),
+                    UntaggedValue::string(cmd.extra_usage().to_string()).into_value(&name),
+                );
+
+                found_cmds_vec
+                    .push(UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&name));
+            }
+        }
+
+        return Ok(found_cmds_vec.into_iter().into_action_stream());
+    }
+
+    if !rest.is_empty() {
+        if rest[0].item == "commands" {
+            let mut sorted_names = scope.get_command_names();
+            sorted_names.sort();
+
+            let (mut subcommand_names, command_names) = sorted_names
+                .into_iter()
+                // private only commands shouldn't be displayed
+                .filter(|cmd_name| {
+                    scope
+                        .get_command(cmd_name)
+                        .filter(|command| !command.is_private())
+                        .is_some()
+                })
+                .partition::<Vec<_>, _>(|cmd_name| cmd_name.contains(' '));
+
+            fn process_name(
+                dict: &mut TaggedDictBuilder,
+                cmd_name: &str,
+                scope: Scope,
+                rest: Vec<Tagged<String>>,
+                name: Tag,
+            ) -> Result<(), ShellError> {
+                let document_tag = rest[0].tag.clone();
+                let value = command_dict(
+                    scope.get_command(cmd_name).ok_or_else(|| {
+                        ShellError::labeled_error(
+                            format!("Could not load {}", cmd_name),
+                            "could not load command",
+                            document_tag,
+                        )
+                    })?,
+                    name,
+                );
+
+                dict.insert_untagged("name", cmd_name);
+                dict.insert_untagged(
+                    "description",
+                    value
+                        .get_data_by_key("usage".spanned_unknown())
+                        .ok_or_else(|| {
+                            ShellError::labeled_error(
+                                "Expected a usage key",
+                                "expected a 'usage' key",
+                                &value.tag,
+                            )
+                        })?
+                        .as_string()?,
+                );
+
+                Ok(())
+            }
+
+            fn make_subcommands_table(
+                subcommand_names: &mut Vec<String>,
+                cmd_name: &str,
+                scope: Scope,
+                rest: Vec<Tagged<String>>,
+                name: Tag,
+            ) -> Result<Value, ShellError> {
+                let (matching, not_matching) =
+                    subcommand_names.drain(..).partition(|subcommand_name| {
+                        subcommand_name.starts_with(&format!("{} ", cmd_name))
+                    });
+                *subcommand_names = not_matching;
+                Ok(if !matching.is_empty() {
+                    UntaggedValue::table(
+                        &(matching
+                            .into_iter()
+                            .map(|cmd_name: String| -> Result<_, ShellError> {
+                                let mut short_desc = TaggedDictBuilder::new(name.clone());
+                                process_name(
+                                    &mut short_desc,
+                                    &cmd_name,
+                                    scope.clone(),
+                                    rest.clone(),
+                                    name.clone(),
+                                )?;
+                                Ok(short_desc.into_value())
+                            })
+                            .collect::<Result<Vec<_>, _>>()?[..]),
+                    )
+                    .into_value(name)
+                } else {
+                    UntaggedValue::nothing().into_value(name)
+                })
+            }
+
+            let iterator =
+                command_names
+                    .into_iter()
+                    .map(move |cmd_name| -> Result<_, ShellError> {
+                        let mut short_desc = TaggedDictBuilder::new(name.clone());
+                        process_name(
+                            &mut short_desc,
+                            &cmd_name,
+                            scope.clone(),
+                            rest.clone(),
+                            name.clone(),
+                        )?;
+                        short_desc.insert_value(
+                            "subcommands",
+                            make_subcommands_table(
+                                &mut subcommand_names,
+                                &cmd_name,
+                                scope.clone(),
+                                rest.clone(),
+                                name.clone(),
+                            )?,
+                        );
+                        ReturnSuccess::value(short_desc.into_value())
+                    });
+
+            Ok(iterator.into_action_stream())
+        } else if rest[0].item == "generate_docs" {
+            Ok(ActionStream::one(ReturnSuccess::value(generate_docs(
+                &scope,
+            ))))
+        } else if rest.len() == 2 {
+            // Check for a subcommand
+            let command_name = format!("{} {}", rest[0].item, rest[1].item);
+            if let Some(command) = scope.get_command(&command_name) {
+                Ok(ActionStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(get_full_help(command.stream_command(), &scope))
+                        .into_value(Tag::unknown()),
+                )))
+            } else {
+                Ok(ActionStream::empty())
+            }
+        } else if let Some(command) = scope.get_command(&rest[0].item) {
+            Ok(ActionStream::one(ReturnSuccess::value(
+                UntaggedValue::string(get_full_help(command.stream_command(), &scope))
+                    .into_value(Tag::unknown()),
+            )))
+        } else {
+            Err(ShellError::labeled_error(
+                "Can't find command (use 'help commands' for full list)",
+                "can't find command",
+                rest[0].tag.span,
+            ))
+        }
+    } else {
+        let msg = r#"Welcome to Nushell.
+
+Here are some tips to help you get started.
+  * help commands - list all available commands
+  * help <command name> - display help about a particular command
+
+Nushell works on the idea of a "pipeline". Pipelines are commands connected with the '|' character.
+Each stage in the pipeline works together to load, parse, and display information to you.
+
+[Examples]
+
+List the files in the current directory, sorted by size:
+    ls | sort-by size
+
+Get information about the current system:
+    sys | get host
+
+Get the processes on your system actively using CPU:
+    ps | where cpu > 0
+
+You can also learn more at https://www.nushell.sh/book/"#;
+
+        Ok(ActionStream::one(ReturnSuccess::value(
+            UntaggedValue::string(msg).into_value(Tag::unknown()),
+        )))
+    }
+}
+
+fn for_spec(name: &str, ty: &str, required: bool, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+
+    let mut spec = TaggedDictBuilder::new(tag);
+
+    spec.insert_untagged("name", UntaggedValue::string(name));
+    spec.insert_untagged("type", UntaggedValue::string(ty));
+    spec.insert_untagged(
+        "required",
+        UntaggedValue::string(if required { "yes" } else { "no" }),
+    );
+
+    spec.into_value()
+}
+
+pub fn signature_dict(signature: Signature, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+    let mut sig = TaggedListBuilder::new(&tag);
+
+    for arg in &signature.positional {
+        let is_required = matches!(arg.0, PositionalType::Mandatory(_, _));
+
+        sig.push_value(for_spec(arg.0.name(), "argument", is_required, &tag));
+    }
+
+    if signature.rest_positional.is_some() {
+        let is_required = false;
+        sig.push_value(for_spec("rest", "argument", is_required, &tag));
+    }
+
+    for (name, ty) in &signature.named {
+        match ty.0 {
+            NamedType::Mandatory(_, _) => sig.push_value(for_spec(name, "flag", true, &tag)),
+            NamedType::Optional(_, _) => sig.push_value(for_spec(name, "flag", false, &tag)),
+            NamedType::Switch(_) => sig.push_value(for_spec(name, "switch", false, &tag)),
+        }
+    }
+
+    sig.into_value()
+}
+
+fn command_dict(command: Command, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+
+    let mut cmd_dict = TaggedDictBuilder::new(&tag);
+
+    cmd_dict.insert_untagged("name", UntaggedValue::string(command.name()));
+
+    cmd_dict.insert_untagged("type", UntaggedValue::string("Command"));
+
+    cmd_dict.insert_value("signature", signature_dict(command.signature(), tag));
+    cmd_dict.insert_untagged("usage", UntaggedValue::string(command.usage()));
+
+    cmd_dict.into_value()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Help;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Help {})
+    }
+}

crates/nu-command/src/commands/core_commands/history.rs

@@ -0,0 +1,74 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+
+pub struct History;
+
+impl WholeStreamCommand for History {
+    fn name(&self) -> &str {
+        "history"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("history").switch("clear", "Clears out the history entries", Some('c'))
+    }
+
+    fn usage(&self) -> &str {
+        "Display command history."
+    }
+
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        history(args)
+    }
+}
+
+fn history(args: CommandArgs) -> Result<ActionStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let ctx = &args.context;
+
+    let clear = args.has_flag("clear");
+
+    let path = if let Some(global_cfg) = &ctx.configs().lock().global_config {
+        nu_data::config::path::history_path_or_default(global_cfg)
+    } else {
+        nu_data::config::path::default_history_path()
+    };
+
+    if clear {
+        // This is a NOOP, the logic to clear is handled in cli.rs
+        Ok(ActionStream::empty())
+    } else if let Ok(file) = File::open(path) {
+        let reader = BufReader::new(file);
+        // Skips the first line, which is a Rustyline internal
+        let output = reader.lines().skip(1).filter_map(move |line| match line {
+            Ok(line) => Some(ReturnSuccess::value(
+                UntaggedValue::string(line).into_value(tag.clone()),
+            )),
+            Err(_) => None,
+        });
+
+        Ok(output.into_action_stream())
+    } else {
+        Err(ShellError::labeled_error(
+            "Could not open history",
+            "history file could not be opened",
+            tag,
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::History;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(History {})
+    }
+}

crates/nu-command/src/commands/core_commands/if_.rs

@@ -0,0 +1,154 @@
+use crate::prelude::*;
+use nu_engine::evaluate_baseline_expr;
+use nu_engine::run_block;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::CapturedBlock, hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue,
+};
+use nu_stream::OutputStream;
+
+pub struct If;
+
+impl WholeStreamCommand for If {
+    fn name(&self) -> &str {
+        "if"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("if")
+            .required(
+                "condition",
+                SyntaxShape::MathExpression,
+                "the condition that must match",
+            )
+            .required(
+                "then_case",
+                SyntaxShape::Block,
+                "block to run if condition is true",
+            )
+            .required(
+                "else_case",
+                SyntaxShape::Block,
+                "block to run if condition is false",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Run blocks if a condition is true or false."
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        if_command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Run a block if a condition is true",
+                example: "let x = 10; if $x > 5 { echo 'greater than 5' } { echo 'less than or equal to 5' }",
+                result: Some(vec![UntaggedValue::string("greater than 5").into()]),
+            },
+            Example {
+                description: "Run a block if a condition is false",
+                example: "let x = 1; if $x > 5 { echo 'greater than 5' } { echo 'less than or equal to 5' }",
+                result: Some(vec![UntaggedValue::string("less than or equal to 5").into()]),
+            },
+        ]
+    }
+}
+fn if_command(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let external_redirection = args.call_info.args.external_redirection;
+    let context = Arc::new(args.context.clone());
+
+    let condition: CapturedBlock = args.req(0)?;
+    let then_case: CapturedBlock = args.req(1)?;
+    let else_case: CapturedBlock = args.req(2)?;
+    let input = args.input;
+
+    let cond = {
+        if condition.block.block.len() != 1 {
+            return Err(ShellError::labeled_error(
+                "Expected a condition",
+                "expected a condition",
+                tag,
+            ));
+        }
+        match condition.block.block[0].pipelines.get(0) {
+            Some(item) => match item.list.get(0) {
+                Some(ClassifiedCommand::Expr(expr)) => expr,
+                _ => {
+                    return Err(ShellError::labeled_error(
+                        "Expected a condition",
+                        "expected a condition",
+                        tag,
+                    ));
+                }
+            },
+            None => {
+                return Err(ShellError::labeled_error(
+                    "Expected a condition",
+                    "expected a condition",
+                    tag,
+                ));
+            }
+        }
+    };
+
+    context.scope.enter_scope();
+    context.scope.add_vars(&condition.captured.entries);
+
+    //FIXME: should we use the scope that's brought in as well?
+    let condition = evaluate_baseline_expr(cond, &context);
+    let result = match condition {
+        Ok(condition) => match condition.as_bool() {
+            Ok(b) => {
+                if b {
+                    run_block(&then_case.block, &context, input, external_redirection)
+                } else {
+                    run_block(&else_case.block, &context, input, external_redirection)
+                }
+            }
+            Err(e) => Ok(OutputStream::from_stream(
+                vec![UntaggedValue::Error(e).into_untagged_value()].into_iter(),
+            )),
+        },
+        Err(e) => Ok(OutputStream::from_stream(
+            vec![UntaggedValue::Error(e).into_untagged_value()].into_iter(),
+        )),
+    };
+    context.scope.exit_scope();
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::If;
+    use super::ShellError;
+    use nu_test_support::nu;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(If {})
+    }
+
+    #[test]
+    fn if_doesnt_leak_on_error() {
+        let actual = nu!(
+            ".",
+            r#"
+                def test-leak [] {
+                    let var = "hello"
+                    if 0 == "" {echo ok} {echo not}
+                }
+                test-leak
+                echo $var
+            "#
+        );
+
+        assert!(actual.err.contains("unknown variable"));
+    }
+}

crates/nu-command/src/commands/core_commands/ignore.rs

@@ -0,0 +1,49 @@
+extern crate unicode_segmentation;
+
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::Signature;
+
+pub struct Ignore;
+
+impl WholeStreamCommand for Ignore {
+    fn name(&self) -> &str {
+        "ignore"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("ignore")
+    }
+
+    fn usage(&self) -> &str {
+        "Ignore the output of the previous command in the pipeline"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let _: Vec<_> = args.input.collect();
+
+        Ok(OutputStream::empty())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Ignore the output of an echo command",
+            example: r#"echo done | ignore"#,
+            result: None,
+        }]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Ignore;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Ignore {})
+    }
+}

crates/nu-command/src/commands/core_commands/let_.rs

@@ -0,0 +1,112 @@
+use crate::prelude::*;
+use nu_engine::{evaluate_baseline_expr, FromValue, WholeStreamCommand};
+
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::{CapturedBlock, ClassifiedCommand},
+    Signature, SyntaxShape, UntaggedValue,
+};
+
+pub struct Let;
+
+impl WholeStreamCommand for Let {
+    fn name(&self) -> &str {
+        "let"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("let")
+            .required("name", SyntaxShape::String, "the name of the variable")
+            .required("equals", SyntaxShape::String, "the equals sign")
+            .required(
+                "expr",
+                SyntaxShape::MathExpression,
+                "the value for the variable",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Create a variable and give it a value."
+    }
+
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        letcmd(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Assign a simple value to a variable",
+                example: "let x = 3",
+                result: Some(vec![]),
+            },
+            Example {
+                description: "Assign the result of an expression to a variable",
+                example: "let result = (3 + 7); echo $result",
+                result: Some(vec![UntaggedValue::int(1).into()]),
+            },
+            Example {
+                description: "Create a variable using the full name",
+                example: "let $three = 3",
+                result: Some(vec![]),
+            },
+        ]
+    }
+}
+
+pub fn letcmd(args: CommandArgs) -> Result<ActionStream, ShellError> {
+    let ctx = &args.context;
+    let positional = args
+        .call_info
+        .args
+        .positional
+        .expect("Internal error: type checker should require args");
+
+    let var_name = positional[0].var_name()?;
+    let rhs_raw = evaluate_baseline_expr(&positional[2], ctx)?;
+    let tag: Tag = positional[2].span.into();
+
+    let rhs: CapturedBlock = FromValue::from_value(&rhs_raw)?;
+
+    let (expr, _) = {
+        if rhs.block.block.len() != 1 {
+            return Err(ShellError::labeled_error(
+                "Expected a value",
+                "expected a value",
+                tag,
+            ));
+        }
+        match rhs.block.block[0].pipelines.get(0) {
+            Some(item) => match item.list.get(0) {
+                Some(ClassifiedCommand::Expr(expr)) => (expr, &rhs.captured),
+                _ => {
+                    return Err(ShellError::labeled_error(
+                        "Expected a value",
+                        "expected a value",
+                        tag,
+                    ));
+                }
+            },
+            None => {
+                return Err(ShellError::labeled_error(
+                    "Expected a value",
+                    "expected a value",
+                    tag,
+                ));
+            }
+        }
+    };
+
+    ctx.scope.enter_scope();
+    let value = evaluate_baseline_expr(expr, ctx);
+    ctx.scope.exit_scope();
+
+    let value = value?;
+
+    // Note: this is a special case for setting the context from a command
+    // In this case, if we don't set it now, we'll lose the scope that this
+    // variable should be set into.
+    ctx.scope.add_var(var_name, value);
+
+    Ok(ActionStream::empty())
+}

crates/nu-command/src/commands/core_commands/mod.rs

@@ -0,0 +1,43 @@
+mod alias;
+mod debug;
+mod def;
+mod describe;
+mod do_;
+pub(crate) mod echo;
+mod error;
+mod find;
+mod help;
+mod history;
+mod if_;
+mod ignore;
+mod let_;
+mod nu_plugin;
+mod nu_signature;
+mod source;
+mod tags;
+mod tutor;
+mod unalias;
+mod version;
+
+pub use self::nu_plugin::SubCommand as NuPlugin;
+pub use self::nu_signature::{
+    loglevels, testbins, version as core_version, Command as NuSignature,
+};
+pub use alias::Alias;
+pub use debug::Debug;
+pub use def::Def;
+pub use describe::Describe;
+pub use do_::Do;
+pub use echo::Echo;
+pub use error::*;
+pub use find::Find;
+pub use help::Help;
+pub use history::History;
+pub use if_::If;
+pub use ignore::Ignore;
+pub use let_::Let;
+pub use source::Source;
+pub use tags::Tags;
+pub use tutor::Tutor;
+pub use unalias::Unalias;
+pub use version::{version, Version};