Bump to 0.28 (#3149)

* move bel and backspace to char since they're not ansi

* Trigger Build

.azure/azure-pipelines.yml

@@ -1,28 +1,37 @@
 trigger:
-  - master
+  - main
 
 strategy:
   matrix:
     linux-stable:
-      image: ubuntu-16.04
+      image: ubuntu-18.04
       style: 'unflagged'
+    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-stable:
-      image: vs2017-win2016
+      image: windows-2019
       style: 'unflagged'
     linux-nightly-canary:
-      image: ubuntu-16.04
+      image: ubuntu-18.04
       style: 'canary'
     macos-nightly-canary:
       image: macos-10.14
       style: 'canary'
     windows-nightly-canary:
-      image: vs2017-win2016
+      image: windows-2019
       style: 'canary'
     fmt:
-      image: ubuntu-16.04
+      image: ubuntu-18.04
       style: 'fmt'
 
 pool:
@@ -34,20 +43,40 @@ steps:
       if [ -e /etc/debian_version ]
       then
         sudo apt-get -y install libxcb-composite0-dev libx11-dev
+        sudo npm install -g wasm-pack
       fi
-      curl https://sh.rustup.rs -sSf | sh -s -- -y --no-modify-path --default-toolchain "stable"
-      export PATH=$HOME/.cargo/bin:$PATH
-      rustup update
-      rustc -Vv
-      echo "##vso[task.prependpath]$HOME/.cargo/bin"
-      rustup component add rustfmt --toolchain "stable"
+      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
+  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used
+    condition: eq(variables['style'], 'unflagged')
+    displayName: Check clippy lints
+  - bash: RUSTFLAGS="-D warnings" cargo test --all
     condition: eq(variables['style'], 'canary')
     displayName: Run tests
+  - bash: cd samples/wasm && wasm-pack build
+    condition: eq(variables['style'], 'wasm')
+    displayName: Wasm build
+  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used
+    condition: eq(variables['style'], 'canary')
+    displayName: Check clippy lints
+  - 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')
     displayName: Lint

.cargo/config

@@ -1,3 +0,0 @@
-[build]
-
-#rustflags = ["--cfg", "coloring_in_tokens"]

.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.md

@@ -12,9 +12,9 @@ A clear and concise description of what the bug is.
 
 **To Reproduce**
 Steps to reproduce the behavior:
-1. 
-2. 
-3. 
+1.
+2.
+3.
 
 **Expected behavior**
 A clear and concise description of what you expected to happen.
@@ -23,8 +23,25 @@ A clear and concise description of what you expected to happen.
 If applicable, add screenshots to help explain your problem.
 
 **Configuration (please complete the following information):**
- - OS: [e.g. Windows]
- - Version [e.g. 0.4.0]
- - Optional features (if any)
 
-Add any other context about the problem here.
+Run `version | pivot` and paste the output to show OS, features, etc.
+
+```
+> version | pivot
+╭───┬────────────────────┬───────────────────────────────────────────────────────────────────────╮
+│ # │ Column0            │ Column1                                                               │
+├───┼────────────────────┼───────────────────────────────────────────────────────────────────────┤
+│ 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, ptree, rich-benchmark, │
+│   │                    │ rustyline, term, uuid, which, zip                                     │
+╰───┴────────────────────┴───────────────────────────────────────────────────────────────────────╯
+```
+
+
+**Add any other context about the problem here.**

.github/workflows/docker-publish.yml

@@ -13,7 +13,7 @@ jobs:
         - x86_64-unknown-linux-musl
         - x86_64-unknown-linux-gnu
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
     - name: Install rust-embedded/cross
       env: { VERSION: v0.1.16 }
       run: >-
@@ -24,7 +24,7 @@ jobs:
       run: |
         cross build --target ${{ matrix.arch }} --release
         # leave only the executable file
-        rm -rd target/${{ matrix.arch }}/release/{*/*,*.d,*.rlib,.fingerprint}
+        rm -frd target/${{ matrix.arch }}/release/{*/*,*.d,*.rlib,.fingerprint}
         find . -empty -delete
     - uses: actions/upload-artifact@master
       with:
@@ -52,17 +52,17 @@ jobs:
         - 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,                 }
+        - { tag: alpine,           base-image: alpine,                     arch: x86_64-unknown-linux-musl, plugin: true,  use-patch: false}
+        - { tag: slim,             base-image: 'debian:stable-slim',       arch: x86_64-unknown-linux-gnu,  plugin: true,  use-patch: false}
+        - { tag: debian,           base-image: debian,                     arch: x86_64-unknown-linux-gnu,  plugin: true,  use-patch: false}
+        - { tag: glibc-busybox,    base-image: 'busybox:glibc',            arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: true }
+        - { tag: musl-busybox,     base-image: 'busybox:musl',             arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
+        - { tag: musl-distroless,  base-image: 'gcr.io/distroless/static', arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
+        - { tag: glibc-distroless, base-image: 'gcr.io/distroless/cc',     arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: true }
+        - { tag: glibc,            base-image: scratch,                    arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: false}
+        - { tag: musl,             base-image: scratch,                    arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
     - uses: actions/download-artifact@master
       with: { name: '${{ matrix.arch }}', path: target/release }
     - name: Build and publish exact version

.github/workflows/release.yml

@@ -0,0 +1,286 @@
+name: Create Release Draft
+
+on:
+  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: 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: 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: 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: applictaion/x-msi

.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 1
+
+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 install nu
+  - 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://github.com/nushell/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,206 +1,266 @@
 [package]
-name = "nu"
-version = "0.6.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.28.0"
 
 [workspace]
-
-members = ["crates/nu-source"]
+members = ["crates/*/"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-source = { version = "0.1.0", path = "./crates/nu-source" }
+nu-cli = { version = "0.28.0", path = "./crates/nu-cli", default-features = false }
+nu-command = { version = "0.28.0", path = "./crates/nu-command" }
+nu-data = { version = "0.28.0", path = "./crates/nu-data" }
+nu-engine = { version = "0.28.0", path = "./crates/nu-engine" }
+nu-errors = { version = "0.28.0", path = "./crates/nu-errors" }
+nu-parser = { version = "0.28.0", path = "./crates/nu-parser" }
+nu-plugin = { version = "0.28.0", path = "./crates/nu-plugin" }
+nu-protocol = { version = "0.28.0", path = "./crates/nu-protocol" }
+nu-source = { version = "0.28.0", path = "./crates/nu-source" }
+nu-value-ext = { version = "0.28.0", path = "./crates/nu-value-ext" }
 
-rustyline = "5.0.4"
-chrono = { version = "0.4.9", features = ["serde"] }
-derive-new = "0.5.8"
-prettytable-rs = "0.8.0"
-itertools = "0.8.1"
-ansi_term = "0.12.1"
-nom = "5.0.1"
-dunce = "1.0.0"
-indexmap = { version = "1.3.0", features = ["serde-1"] }
-chrono-humanize = "0.0.11"
-byte-unit = "3.0.3"
-base64 = "0.11"
-futures-preview = { version = "=0.3.0-alpha.19", features = ["compat", "io-compat"] }
-async-stream = "0.1.2"
-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.102", features = ["derive"] }
-bson = { version = "0.14.0", features = ["decimal128"] }
-serde_json = "1.0.41"
-serde-hjson = "0.9.1"
-serde_yaml = "0.8"
-serde_bytes = "0.11.2"
-getset = "0.0.9"
-language-reporting = "0.4.0"
-app_dirs = "1.2.1"
-csv = "1.1"
-toml = "0.5.5"
-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.3"
-url = "2.1.0"
-roxmltree = "0.7.2"
-nom_locate = "1.0.0"
-nom-tracable = "0.4.1"
-unicode-xid = "0.2.0"
-serde_ini = "0.2.0"
-subprocess = "0.1.18"
-mime = "0.3.14"
-pretty-hex = "0.1.1"
-hex = "0.4"
-tempfile = "3.1.0"
-semver = "0.9.0"
-which = "3.1"
-textwrap = {version = "0.11.0", features = ["term_size"]}
-shellexpand = "1.0.0"
-futures-timer = "2.0.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.6"
-trash = "1.0.0"
-regex = "1"
-cfg-if = "0.1"
-strip-ansi-escapes = "0.1.0"
-calamine = "0.16"
-umask = "0.1"
-futures-util = "0.3.0"
-pretty = "0.5.2"
-termcolor = "1.0.5"
-console = "0.9.1"
+nu_plugin_binaryview = { version = "0.28.0", path = "./crates/nu_plugin_binaryview", optional = true }
+nu_plugin_chart = { version = "0.28.0", path = "./crates/nu_plugin_chart", optional = true }
+nu_plugin_fetch = { version = "0.28.0", path = "./crates/nu_plugin_fetch", optional = true }
+nu_plugin_from_bson = { version = "0.28.0", path = "./crates/nu_plugin_from_bson", optional = true }
+nu_plugin_from_sqlite = { version = "0.28.0", path = "./crates/nu_plugin_from_sqlite", optional = true }
+nu_plugin_inc = { version = "0.28.0", path = "./crates/nu_plugin_inc", optional = true }
+nu_plugin_match = { version = "0.28.0", path = "./crates/nu_plugin_match", optional = true }
+nu_plugin_post = { version = "0.28.0", path = "./crates/nu_plugin_post", optional = true }
+nu_plugin_ps = { version = "0.28.0", path = "./crates/nu_plugin_ps", optional = true }
+nu_plugin_s3 = { version = "0.28.0", path = "./crates/nu_plugin_s3", optional = true }
+nu_plugin_selector = { version = "0.28.0", path = "./crates/nu_plugin_selector", optional = true }
+nu_plugin_start = { version = "0.28.0", path = "./crates/nu_plugin_start", optional = true }
+nu_plugin_sys = { version = "0.28.0", path = "./crates/nu_plugin_sys", optional = true }
+nu_plugin_textview = { version = "0.28.0", path = "./crates/nu_plugin_textview", optional = true }
+nu_plugin_to_bson = { version = "0.28.0", path = "./crates/nu_plugin_to_bson", optional = true }
+nu_plugin_to_sqlite = { version = "0.28.0", path = "./crates/nu_plugin_to_sqlite", optional = true }
+nu_plugin_tree = { version = "0.28.0", path = "./crates/nu_plugin_tree", optional = true }
+nu_plugin_xpath = { version = "0.28.0", path = "./crates/nu_plugin_xpath", 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" }
-image = { version = "0.22.2", default_features = false, features = ["png_codec", "jpeg"], optional = true }
-starship = { version = "0.26.4", optional = true}
-
-[features]
-default = ["textview", "sys", "ps"]
-raw-key = ["rawkey", "neso"]
-textview = ["syntect", "onig_sys", "crossterm"]
-binaryview = ["image", "crossterm"]
-sys = ["heim", "battery"]
-ps = ["heim"]
-starship-prompt = ["starship"]
-# trace = ["nom-tracable/trace"]
-
-[dependencies.rusqlite]
-version = "0.20.0"
-features = ["bundled", "blob"]
+# Required to bootstrap the main binary
+clap = "2.33.3"
+ctrlc = { version = "3.1.7", optional = true }
+futures = { version = "0.3.12", features = ["compat", "io-compat"] }
+itertools = "0.10.0"
+log = "0.4.14"
+pretty_env_logger = "0.4.0"
 
 [dev-dependencies]
-pretty_assertions = "0.6.1"
+nu-test-support = { version = "0.28.0", path = "./crates/nu-test-support" }
+dunce = "1.0.1"
+serial_test = "0.5.1"
+
 
 [build-dependencies]
-toml = "0.5.5"
-serde = { version = "1.0.102", features = ["derive"] }
 
-[lib]
-name = "nu"
-path = "src/lib.rs"
+[features]
+ctrlc-support = ["nu-cli/ctrlc", "nu-command/ctrlc"]
+directories-support = [
+    "nu-cli/directories",
+    "nu-cli/dirs",
+    "nu-command/directories",
+    "nu-command/dirs",
+    "nu-data/directories",
+    "nu-data/dirs",
+    "nu-engine/dirs",
+]
+ptree-support = ["nu-cli/ptree", "nu-command/ptree"]
+rustyline-support = ["nu-cli/rustyline-support", "nu-command/rustyline-support"]
+term-support = ["nu-cli/term", "nu-command/term"]
+uuid-support = ["nu-cli/uuid_crate", "nu-command/uuid_crate"]
+which-support = [
+    "nu-cli/ichwh",
+    "nu-cli/which",
+    "nu-command/ichwh",
+    "nu-command/which",
+]
 
+default = [
+    "nu-cli/shadow-rs",
+    "sys",
+    "ps",
+    "textview",
+    "inc",
+    "directories-support",
+    "ctrlc-support",
+    "which-support",
+    "ptree-support",
+    "term-support",
+    "uuid-support",
+    "rustyline-support",
+    "match",
+    "post",
+    "fetch",
+    "zip-support",
+]
+
+stable = ["default"]
+extra = [
+    "default",
+    "binaryview",
+    "tree",
+    "clipboard-cli",
+    "trash-support",
+    "start",
+    "bson",
+    "sqlite",
+    "s3",
+    "chart",
+    "xpath",
+    "selector",
+]
+
+wasi = ["inc", "match", "ptree-support", "match", "tree", "rustyline-support"]
+
+trace = ["nu-parser/trace"]
+
+# Stable (Default)
+fetch = ["nu_plugin_fetch"]
+inc = ["nu_plugin_inc"]
+match = ["nu_plugin_match"]
+post = ["nu_plugin_post"]
+ps = ["nu_plugin_ps"]
+sys = ["nu_plugin_sys"]
+textview = ["nu_plugin_textview"]
+zip-support = ["nu-cli/zip", "nu-command/zip"]
+
+# Extra
+binaryview = ["nu_plugin_binaryview"]
+bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
+chart = ["nu_plugin_chart"]
+clipboard-cli = ["nu-cli/clipboard-cli", "nu-command/clipboard-cli"]
+s3 = ["nu_plugin_s3"]
+selector = ["nu_plugin_selector"]
+sqlite = ["nu_plugin_from_sqlite", "nu_plugin_to_sqlite"]
+start = ["nu_plugin_start"]
+trash-support = [
+    "nu-cli/trash-support",
+    "nu-command/trash-support",
+    "nu-engine/trash-support",
+]
+tree = ["nu_plugin_tree"]
+xpath = ["nu_plugin_xpath"]
+#This is disabled in extra for now
+table-pager = ["nu-command/table-pager"]
+
+[profile.release]
+#strip = "symbols" #Couldn't get working +nightly
+codegen-units = 1 #Reduce parallel codegen units
+lto = true #Link Time Optimization
+opt-level = 'z' #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_average"
-path = "src/plugins/average.rs"
-
-[[bin]]
-name = "nu_plugin_embed"
-path = "src/plugins/embed.rs"
-
-[[bin]]
-name = "nu_plugin_insert"
-path = "src/plugins/insert.rs"
-
-[[bin]]
-name = "nu_plugin_edit"
-path = "src/plugins/edit.rs"
-
-[[bin]]
-name = "nu_plugin_format"
-path = "src/plugins/format.rs"
-
-[[bin]]
-name = "nu_plugin_parse"
-path = "src/plugins/parse.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"
-
-[[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_ps"
+path = "src/plugins/nu_plugin_core_ps.rs"
+required-features = ["ps"]
+
+[[bin]]
+name = "nu_plugin_core_sys"
+path = "src/plugins/nu_plugin_core_sys.rs"
+required-features = ["sys"]
+
+[[bin]]
+name = "nu_plugin_core_fetch"
+path = "src/plugins/nu_plugin_core_fetch.rs"
+required-features = ["fetch"]
+
+[[bin]]
+name = "nu_plugin_core_match"
+path = "src/plugins/nu_plugin_core_match.rs"
+required-features = ["match"]
+
+[[bin]]
+name = "nu_plugin_core_post"
+path = "src/plugins/nu_plugin_core_post.rs"
+required-features = ["post"]
+
+# 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_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 - 2020 Yehuda Katz, Jonathan Turner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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,71 +1,94 @@
+# 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).  **Windows users**: please note that Nu works on Windows 10 and does not currently have Windows 7/8.1 support.
+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 **latest stable (1.39 or later)** version of the compiler.
+To build Nu, you will need to use the **latest stable (1.47 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 latest stable compiler via `rustup install stable`):
 
-```
+```bash
 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):
+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:
 
-```
-cargo install nu --all-features
+```bash
+cargo build --workspace --features=extra
 ```
 
-## Docker
+### Docker
+
+#### Quickstart
+
+Want to try Nu right away? Execute the following to get started.
+
+```bash
+docker run -it quay.io/nushell/nu:latest
+```
+
+#### Guide
 
 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
+docker pull quay.io/nushell/nu
+docker pull quay.io/nushell/nu-base
 ```
 
 Both "nu-base" and "nu" provide the nu binary, however nu-base also includes the source code at `/code`
@@ -75,269 +98,228 @@ Optionally, you can also build the containers locally using the [dockerfiles pro
 To build the base image:
 
 ```bash
-$ docker build -f docker/Dockerfile.nu-base -t nushell/nu-base .
+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 .
+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
+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 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:
 
-* 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 (eg, `ls`)
+-   Commands that filter a stream (eg, `where type == "Dir"`)
+-   Commands that consume the output of the pipeline (eg, `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 as well 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 as 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.6.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.21.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.6.0
+```shell
+> open Cargo.toml | get package.version
+0.21.0
 ```
 
 Here we use the variable `$it` to refer to the value being piped to the external command.
 
-## Configuration
+### Configuration
 
-Nu has early support for configuring the shell. It currently supports the following settings:
+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).
 
-| Variable        | Type           | Description  |
-| ------------- | ------------- | ----- |
-| path | table of strings | PATH to use to find binaries |
-| env | row | the environment variables to pass to external commands |
-| ctrlc_exit | boolean | whether or not to exit Nu after multiple ctrl-c presses |
-| table_mode | "light" or other | enable lightweight or normal tables |
-| edit_mode | "vi" or "emacs" | changes line editing to "vi" or "emacs" mode |
+To set one of these variables, you can use `config set`. For example:
 
-To set one of these variables, you can use `config --set`. For example:
-
-```
-> config --set [edit_mode "vi"]
-> config --set [path $nu:path]
+```shell
+> config set line_editor.edit_mode "vi"
+> config set path $nu.path
 ```
 
-## Shells
+### 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 at the same time.
+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 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.
+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.
 
 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, 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.
 
-# 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 first-class consistent 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 |
-| ------------- | ------------- |
-| append row-data | Append a row to the end of the table |
-| compact ...columns | Remove rows where given columns are empty |
-| count | Show the total number of rows |
-| default column row-data | Sets a default row's column if missing |
-| 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 |
-| format pattern | Format table row data as a string following the given pattern |
-| get column-or-column-path | Open column and get data from the corresponding cells |
-| group-by column | Creates a new table with the data from the table rows grouped by the column given |
-| histogram column ...column-names | Creates a new table with a histogram based on the column name passed in, optionally give the frequency column name
-| inc (column-or-column-path) | Increment a value or version. Optionally use the column of a table |
-| insert column-or-column-path value | Insert a new column to the table |
-| last amount | Show only the last number of rows |
-| nth ...row-numbers | Return only the selected rows |
-| pick ...columns | Down-select table to only these columns |
-| pivot --header-row <headers> | Pivot the tables, making columns into rows and vice versa |
-| prepend row-data | Prepend a row to the beginning of the table |
-| 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 |
-| split-by column | Creates a new table with the data from the inner tables splitted by the column given |
-| 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 |
-| parse pattern | Convert text to a table by matching the given pattern |
-| 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     |     |         |        | Initial implementation but lacks necessary features                  |
+| 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, but no session-wide env 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 and related are barebones and lack task-based lessons           |
+| Paging        |             |     X     |     |         |        | Textview has paging, but we'd like paging for tables                 |
+| Functions     |             |     X     |     |         |        | No functions, yet, only aliases                                      |
+| Variables     |             |     X     |     |         |        | Nu doesn't yet support variables                                     |
+| Completions   |             |     X     |     |         |        | Completions are currently barebones, at best                         |
+| Type-checking |             |     X     |     |         |        | Commands check basic types, but input/output isn't checked           |
 
-# License
+## Current Roadmap
 
-The project is made available under the MIT license. See "LICENSE" for more information.
+We've added a `Roadmap Board` to help collaboratively capture the direction we're going for the current release as well as capture some important issues we'd like to see in Nushell. You can find the Roadmap [here](https://github.com/nushell/nushell/projects/2).
 
+## 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.

TODO.md

@@ -1,48 +0,0 @@
-This pattern is extremely repetitive and can be abstracted:
-
-```rs
-    let args = args.evaluate_once(registry)?;
-    let tag = args.name_tag();
-    let input = args.input;
-
-    let stream = async_stream! {
-        let values: Vec<Value> = input.values.collect().await;
-
-        let mut concat_string = String::new();
-        let mut latest_tag: Option<Tag> = None;
-
-        for value in values {
-            latest_tag = Some(value_tag.clone());
-            let value_span = value.tag.span;
-
-            match &value.value {
-                UntaggedValue::Primitive(Primitive::String(s)) => {
-                    concat_string.push_str(&s);
-                    concat_string.push_str("\n");
-                }
-                _ => yield Err(ShellError::labeled_error_with_secondary(
-                    "Expected a string from pipeline",
-                    "requires string input",
-                    name_span,
-                    "value originates from here",
-                    value_span,
-                )),
-
-            }
-        }
-
-```
-
-Mandatory and Optional in parse_command
-
-trace_remaining?
-
-select_fields and select_fields take unnecessary Tag
-
-Value#value should be Value#untagged
-
-Unify dictionary building, probably around a macro
-
-sys plugin in own crate
-
-textview in own crate

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/nu-ansi-term/.gitignore

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

crates/nu-ansi-term/Cargo.toml

@@ -0,0 +1,35 @@
+[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.28.0"
+
+[lib]
+doctest = false
+# name = "nu-ansi-term"
+
+[features]
+derive_serde_style = ["serde"]
+
+[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/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,404 @@
+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::NoDifference => {
+                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.
+    NoDifference,
+}
+
+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 NoDifference;
+        }
+
+        // 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()  => NoDifference);
+    test!(uppercase:  Green.normal(); Green.bold()    => ExtraStyles(style().bold()));
+    test!(lowercase:  Green.bold();   Green.normal()  => Reset);
+    test!(nothing2:   Green.bold();   Green.bold()    => NoDifference);
+
+    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 `ANSIGenericString`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())?,
+                NoDifference => { /* 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 = format!("{}", ANSIStrings(&[one, two]));
+        assert_eq!(&*output, "onetwo");
+    }
+}

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

@@ -0,0 +1,267 @@
+//! 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");
+
+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;

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

@@ -0,0 +1,620 @@
+/// 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 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.into_iter() {
+            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).as_slice(), &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,135 @@
+[package]
+authors = ["The Nu Project Contributors"]
+build = "build.rs"
+description = "CLI for nushell"
+edition = "2018"
+license = "MIT"
+name = "nu-cli"
+version = "0.28.0"
+
+[lib]
+doctest = false
+
+[dependencies]
+nu-command = { version = "0.28.0", path = "../nu-command" }
+nu-data = { version = "0.28.0", path = "../nu-data" }
+nu-engine = { version = "0.28.0", path = "../nu-engine" }
+nu-errors = { version = "0.28.0", path = "../nu-errors" }
+nu-json = { version = "0.28.0", path = "../nu-json" }
+nu-parser = { version = "0.28.0", path = "../nu-parser" }
+nu-plugin = { version = "0.28.0", path = "../nu-plugin" }
+nu-protocol = { version = "0.28.0", path = "../nu-protocol" }
+nu-source = { version = "0.28.0", path = "../nu-source" }
+nu-stream = { version = "0.28.0", path = "../nu-stream" }
+nu-table = { version = "0.28.0", path = "../nu-table" }
+nu-test-support = { version = "0.28.0", path = "../nu-test-support" }
+nu-value-ext = { version = "0.28.0", path = "../nu-value-ext" }
+nu-ansi-term = { version = "0.28.0", path = "../nu-ansi-term" }
+
+Inflector = "0.11"
+arboard = { version = "1.1.0", optional = true }
+async-recursion = "0.3.2"
+async-trait = "0.1.42"
+base64 = "0.13.0"
+bigdecimal = { version = "0.2.0", features = ["serde"] }
+byte-unit = "4.0.9"
+bytes = "1.0.1"
+calamine = "0.17.0"
+chrono = { version = "0.4.19", features = ["serde"] }
+chrono-tz = "0.5.3"
+clap = "2.33.3"
+codespan-reporting = "0.11.0"
+csv = "1.1.5"
+ctrlc = { version = "3.1.7", optional = true }
+derive-new = "0.5.8"
+directories-next = { version = "2.0.0", optional = true }
+dirs-next = { version = "2.0.0", optional = true }
+dtparse = "1.2.0"
+dunce = "1.0.1"
+eml-parser = "0.1.0"
+encoding_rs = "0.8.28"
+filesize = "0.2.0"
+fs_extra = "1.2.0"
+futures = { version = "0.3.12", features = ["compat", "io-compat"] }
+futures-util = "0.3.12"
+futures_codec = "0.4.1"
+getset = "0.1.1"
+glob = "0.3.0"
+htmlescape = "0.3.1"
+ical = "0.7.0"
+ichwh = { version = "0.3.4", optional = true }
+indexmap = { version = "1.6.1", features = ["serde-1"] }
+itertools = "0.10.0"
+lazy_static = "1.*"
+log = "0.4.14"
+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"
+pin-utils = "0.1.0"
+pretty-hex = "0.2.1"
+ptree = { version = "0.3.1", optional = true }
+query_interface = "0.3.5"
+quick-xml = "0.21.0"
+rand = "0.8.3"
+rayon = "1.5.0"
+regex = "1.4.3"
+roxmltree = "0.14.0"
+rust-embed = "5.9.0"
+rustyline = { version = "6.3.0", optional = true }
+serde = { version = "1.0.123", features = ["derive"] }
+serde_bytes = "0.11.5"
+serde_ini = "0.2.0"
+serde_json = "1.0.61"
+serde_urlencoded = "0.7.0"
+serde_yaml = "0.8.16"
+sha2 = "0.9.3"
+shellexpand = "2.1.0"
+strip-ansi-escapes = "0.1.0"
+sxd-document = "0.3.2"
+sxd-xpath = "0.4.2"
+tempfile = "3.2.0"
+term = { version = "0.7.0", optional = true }
+term_size = "0.3.2"
+termcolor = "1.1.2"
+titlecase = "1.1.0"
+toml = "0.5.8"
+trash = { version = "1.3.0", optional = true }
+unicode-segmentation = "1.7.1"
+url = "2.1.1"
+uuid_crate = { package = "uuid", version = "0.8.2", features = ["v4"], optional = true }
+which = { version = "4.0.2", optional = true }
+zip = { version = "0.5.9", optional = true }
+shadow-rs = { version = "0.5", default-features = false, optional = true }
+
+[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"]}
+
+[dependencies.rusqlite]
+features = ["bundled", "blob"]
+optional = true
+version = "0.24.2"
+
+[build-dependencies]
+shadow-rs = "0.5"
+
+[dev-dependencies]
+quickcheck = "1.0.3"
+quickcheck_macros = "1.0.0"
+
+[features]
+default = ["shadow-rs"]
+clipboard-cli = ["arboard"]
+rustyline-support = ["rustyline", "nu-engine/rustyline-support"]
+stable = []
+trash-support = ["trash"]
+dirs = ["dirs-next"]
+directories = ["directories-next"]

crates/nu-cli/build.rs

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

crates/nu-cli/src/cli.rs

@@ -0,0 +1,441 @@
+use crate::line_editor::configure_ctrl_c;
+use nu_command::commands::default_context::create_default_context;
+#[allow(unused_imports)]
+use nu_command::maybe_print_errors;
+use nu_engine::run_block;
+use nu_engine::EvaluationContext;
+
+#[allow(unused_imports)]
+pub(crate) use nu_command::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;
+
+use nu_command::script::{print_err, run_script_standalone};
+
+#[cfg(feature = "rustyline-support")]
+use rustyline::{self, error::ReadlineError};
+
+use crate::EnvironmentSyncer;
+use nu_errors::ShellError;
+use nu_parser::ParserScope;
+use nu_protocol::{hir::ExternalRedirection, UntaggedValue, Value};
+
+use log::trace;
+use std::error::Error;
+use std::iter::Iterator;
+use std::path::PathBuf;
+
+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(PathBuf::from(plugin_dir));
+                }
+            }
+        }
+    }
+
+    search_paths
+}
+
+pub async fn run_script_file(
+    file_contents: String,
+    redirect_stdin: bool,
+) -> Result<(), Box<dyn Error>> {
+    let mut syncer = EnvironmentSyncer::new();
+    let mut context = create_default_context(false)?;
+    let config = syncer.get_config();
+
+    context.configure(&config, |_, ctx| {
+        syncer.load_environment();
+        syncer.sync_env_vars(ctx);
+        syncer.sync_path_vars(ctx);
+
+        if let Err(reason) = syncer.autoenv(ctx) {
+            print_err(reason, &Text::from(""), ctx);
+        }
+
+        let _ = register_plugins(ctx);
+        let _ = configure_ctrl_c(ctx);
+    });
+
+    let _ = run_startup_commands(&mut context, &config).await;
+
+    run_script_standalone(file_contents, redirect_stdin, &context, true).await?;
+
+    Ok(())
+}
+
+/// The entry point for the CLI. Will register all known internal commands, load experimental commands, load plugins, then prepare the prompt and line reader for input.
+#[cfg(feature = "rustyline-support")]
+pub async fn cli(mut context: EvaluationContext) -> Result<(), Box<dyn Error>> {
+    let mut syncer = EnvironmentSyncer::new();
+    let configuration = syncer.get_config();
+
+    let mut rl = default_rustyline_editor_configuration();
+
+    context.configure(&configuration, |config, ctx| {
+        syncer.load_environment();
+        syncer.sync_env_vars(ctx);
+        syncer.sync_path_vars(ctx);
+
+        if let Err(reason) = syncer.autoenv(ctx) {
+            print_err(reason, &Text::from(""), ctx);
+        }
+
+        let _ = configure_ctrl_c(ctx);
+        let _ = configure_rustyline_editor(&mut rl, config);
+
+        let helper = Some(nu_line_editor_helper(ctx, config));
+        rl.set_helper(helper);
+    });
+
+    // start time for command duration
+    let startup_commands_start_time = std::time::Instant::now();
+    // run the startup commands
+    let _ = run_startup_commands(&mut context, &configuration).await;
+    // Store cmd duration in an env var
+    context.scope.add_env_var(
+        "CMD_DURATION",
+        format!("{:?}", startup_commands_start_time.elapsed()),
+    );
+    trace!(
+        "startup commands took {:?}",
+        startup_commands_start_time.elapsed()
+    );
+
+    // Give ourselves a scope to work in
+    context.scope.enter_scope();
+
+    let history_path = nu_engine::history_path(&configuration);
+    let _ = rl.load_history(&history_path);
+
+    let mut session_text = String::new();
+    let mut line_start: usize = 0;
+
+    let skip_welcome_message = configuration
+        .var("skip_welcome_message")
+        .map(|x| x.is_true())
+        .unwrap_or(false);
+    if !skip_welcome_message {
+        println!(
+            "Welcome to Nushell {} (type 'help' for more info)",
+            clap::crate_version!()
+        );
+    }
+
+    #[cfg(windows)]
+    {
+        let _ = nu_ansi_term::enable_ansi_support();
+    }
+
+    let mut ctrlcbreak = false;
+
+    loop {
+        if context.ctrl_c.load(Ordering::SeqCst) {
+            context.ctrl_c.store(false, Ordering::SeqCst);
+            continue;
+        }
+
+        let cwd = context.shell_manager.path();
+
+        let colored_prompt = {
+            if let Some(prompt) = configuration.var("prompt") {
+                let prompt_line = prompt.as_string()?;
+
+                context.scope.enter_scope();
+                let (mut prompt_block, err) = nu_parser::parse(&prompt_line, 0, &context.scope);
+
+                prompt_block.set_redirect(ExternalRedirection::Stdout);
+
+                if err.is_some() {
+                    context.scope.exit_scope();
+
+                    format!("\x1b[32m{}{}\x1b[m> ", cwd, current_branch())
+                } else {
+                    // let env = context.get_env();
+
+                    let run_result = run_block(&prompt_block, &context, InputStream::empty()).await;
+                    context.scope.exit_scope();
+
+                    match run_result {
+                        Ok(result) => match result.collect_string(Tag::unknown()).await {
+                            Ok(string_result) => {
+                                let errors = context.get_errors();
+                                maybe_print_errors(&context, Text::from(prompt_line));
+                                context.clear_errors();
+
+                                if !errors.is_empty() {
+                                    "> ".to_string()
+                                } else {
+                                    string_result.item
+                                }
+                            }
+                            Err(e) => {
+                                crate::cli::print_err(e, &Text::from(prompt_line), &context);
+                                context.clear_errors();
+
+                                "> ".to_string()
+                            }
+                        },
+                        Err(e) => {
+                            crate::cli::print_err(e, &Text::from(prompt_line), &context);
+                            context.clear_errors();
+
+                            "> ".to_string()
+                        }
+                    }
+                }
+            } else {
+                format!("\x1b[32m{}{}\x1b[m> ", cwd, current_branch())
+            }
+        };
+
+        let prompt = {
+            if let Ok(bytes) = strip_ansi_escapes::strip(&colored_prompt) {
+                String::from_utf8_lossy(&bytes).to_string()
+            } else {
+                "> ".to_string()
+            }
+        };
+
+        rl.helper_mut().expect("No 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,
+                )
+                .await
+            }
+            x => x,
+        };
+
+        // Store cmd duration in an env var
+        context
+            .scope
+            .add_env_var("CMD_DURATION", format!("{:?}", cmd_start_time.elapsed()));
+
+        // Check the config to see if we need to update the path
+        // TODO: make sure config is cached so we don't path this load every call
+        // FIXME: we probably want to be a bit more graceful if we can't set the environment
+
+        context.configure(&configuration, |config, ctx| {
+            if syncer.did_config_change() {
+                syncer.reload();
+                syncer.sync_env_vars(ctx);
+                syncer.sync_path_vars(ctx);
+            }
+
+            if let Err(reason) = syncer.autoenv(ctx) {
+                print_err(reason, &Text::from(""), ctx);
+            }
+
+            let _ = configure_rustyline_editor(&mut rl, config);
+        });
+
+        match line {
+            LineResult::Success(line) => {
+                rl.add_history_entry(&line);
+                let _ = rl.save_history(&history_path);
+                maybe_print_errors(&context, Text::from(session_text.clone()));
+            }
+
+            LineResult::ClearHistory => {
+                rl.clear_history();
+                let _ = rl.save_history(&history_path);
+            }
+
+            LineResult::Error(line, err) => {
+                rl.add_history_entry(&line);
+                let _ = rl.save_history(&history_path);
+
+                print_err(err, &Text::from(session_text.clone()), &context);
+
+                maybe_print_errors(&context, Text::from(session_text.clone()));
+            }
+
+            LineResult::CtrlC => {
+                let config_ctrlc_exit = config::config(Tag::unknown())?
+                    .get("ctrlc_exit")
+                    .map(|s| s.value.is_true())
+                    .unwrap_or(false); // default behavior is to allow CTRL-C spamming similar to other shells
+
+                if !config_ctrlc_exit {
+                    continue;
+                }
+
+                if ctrlcbreak {
+                    let _ = rl.save_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
+    let _ = rl.save_history(&history_path);
+
+    Ok(())
+}
+
+pub fn register_plugins(context: &mut 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(())
+}
+
+async fn run_startup_commands(
+    context: &mut EvaluationContext,
+    config: &dyn nu_data::config::Conf,
+) -> Result<(), ShellError> {
+    if let Some(commands) = config.var("startup") {
+        match commands {
+            Value {
+                value: UntaggedValue::Table(pipelines),
+                ..
+            } => {
+                let mut script_file = String::new();
+                for pipeline in pipelines {
+                    script_file.push_str(&pipeline.as_string()?);
+                    script_file.push('\n');
+                }
+                let _ = run_script_standalone(script_file, false, context, false).await;
+            }
+            _ => {
+                return Err(ShellError::untagged_runtime_error(
+                    "expected a table of pipeline strings as startup commands",
+                ));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub async 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 env = ctx.get_env();
+    ctx.scope.add_env(env);
+
+    let result = run_block(&classified_block, ctx, input_stream).await;
+    ctx.scope.exit_scope();
+
+    result?.collect_string(Tag::unknown()).await.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()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use nu_engine::basic_evaluation_context;
+
+    #[quickcheck]
+    fn quickcheck_parse(data: String) -> bool {
+        let (tokens, err) = nu_parser::lex(&data, 0);
+        let (lite_block, err2) = nu_parser::parse_block(tokens);
+        if err.is_none() && err2.is_none() {
+            let context = basic_evaluation_context().unwrap();
+            let _ = nu_parser::classify_block(&lite_block, &context.scope);
+        }
+        true
+    }
+}

crates/nu-cli/src/completion/command.rs

@@ -0,0 +1,141 @@
+use std::iter::FromIterator;
+use std::path::Path;
+
+use indexmap::set::IndexSet;
+
+use super::matchers::Matcher;
+use crate::completion::{Completer, CompletionContext, Suggestion};
+use nu_engine::EvaluationContext;
+
+pub struct CommandCompleter;
+
+impl Completer for CommandCompleter {
+    fn complete(
+        &self,
+        ctx: &CompletionContext<'_>,
+        partial: &str,
+        matcher: &dyn Matcher,
+    ) -> Vec<Suggestion> {
+        let context: &EvaluationContext = ctx.as_ref();
+        let mut commands: IndexSet<String> = IndexSet::from_iter(context.scope.get_command_names());
+
+        // Command suggestions can come from three possible sets:
+        //   1. internal command names,
+        //   2. external command names relative to PATH env var, and
+        //   3. any other executable (that matches what's been typed so far).
+
+        let path_executables = find_path_executables().unwrap_or_default();
+
+        // TODO quote these, if necessary
+        commands.extend(path_executables.into_iter());
+
+        let mut suggestions: Vec<_> = commands
+            .into_iter()
+            .filter(|v| matcher.matches(partial, v))
+            .map(|v| Suggestion {
+                replacement: v.clone(),
+                display: v,
+            })
+            .collect();
+
+        if !partial.is_empty() {
+            let path_completer = crate::completion::path::PathCompleter;
+            let path_results = path_completer.path_suggestions(partial, matcher);
+            let iter = path_results.into_iter().filter_map(|path_suggestion| {
+                let path = path_suggestion.path;
+                if path.is_dir() || is_executable(&path) {
+                    Some(path_suggestion.suggestion)
+                } else {
+                    None
+                }
+            });
+
+            suggestions.extend(iter);
+        }
+
+        suggestions
+    }
+}
+
+// TODO create a struct for "is executable" and store this information in it so we don't recompute
+//      on every dir entry
+
+#[cfg(windows)]
+fn pathext() -> Option<Vec<String>> {
+    std::env::var_os("PATHEXT").map(|v| {
+        v.to_string_lossy()
+            .split(';')
+            // Filter out empty tokens and ';' at the end
+            .filter(|f| f.len() > 1)
+            // Cut off the leading '.' character
+            .map(|ext| ext[1..].to_string())
+            .collect::<Vec<_>>()
+    })
+}
+
+#[cfg(windows)]
+fn is_executable(path: &Path) -> bool {
+    if let Ok(metadata) = path.metadata() {
+        let file_type = metadata.file_type();
+
+        // If the entry isn't a file, it cannot be executable
+        if !(file_type.is_file() || file_type.is_symlink()) {
+            return false;
+        }
+
+        if let Some(extension) = path.extension() {
+            if let Some(exts) = pathext() {
+                exts.iter()
+                    .any(|ext| extension.to_string_lossy().eq_ignore_ascii_case(ext))
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    } else {
+        false
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+fn is_executable(_path: &Path) -> bool {
+    false
+}
+
+#[cfg(unix)]
+fn is_executable(path: &Path) -> bool {
+    use std::os::unix::fs::PermissionsExt;
+
+    if let Ok(metadata) = path.metadata() {
+        let filetype = metadata.file_type();
+        let permissions = metadata.permissions();
+
+        // The file is executable if it is a directory or a symlink and the permissions are set for
+        // owner, group, or other
+        (filetype.is_file() || filetype.is_symlink()) && (permissions.mode() & 0o111 != 0)
+    } else {
+        false
+    }
+}
+
+// TODO cache these, but watch for changes to PATH
+fn find_path_executables() -> Option<IndexSet<String>> {
+    let path_var = std::env::var_os("PATH")?;
+    let paths: Vec<_> = std::env::split_paths(&path_var).collect();
+
+    let mut executables: IndexSet<String> = IndexSet::new();
+    for path in paths {
+        if let Ok(mut contents) = std::fs::read_dir(path) {
+            while let Some(Ok(item)) = contents.next() {
+                if is_executable(&item.path()) {
+                    if let Ok(name) = item.file_name().into_string() {
+                        executables.insert(name);
+                    }
+                }
+            }
+        }
+    }
+
+    Some(executables)
+}

crates/nu-cli/src/completion/engine.rs

@@ -0,0 +1,434 @@
+use nu_protocol::hir::*;
+use nu_source::{Span, Spanned, SpannedItem};
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum LocationType {
+    Command,
+    Flag(String),                             // command name
+    Argument(Option<String>, Option<String>), // command name, argument name
+    Variable,
+}
+
+pub type CompletionLocation = Spanned<LocationType>;
+
+// TODO The below is very similar to shapes / expression_to_flat_shape. Check back October 2020
+//      to see if we're close enough to just make use of those.
+
+struct Flatten<'s> {
+    line: &'s str,
+    command: Option<String>,
+    flag: Option<String>,
+}
+
+impl<'s> Flatten<'s> {
+    /// Converts a SpannedExpression into a completion location for use in NuCompleter
+    fn expression(&self, e: &SpannedExpression) -> Vec<CompletionLocation> {
+        match &e.expr {
+            Expression::Block(block) => self.completion_locations(block),
+            Expression::Invocation(block) => self.completion_locations(block),
+            Expression::List(exprs) => exprs.iter().flat_map(|v| self.expression(v)).collect(),
+            Expression::Table(headers, cells) => headers
+                .iter()
+                .flat_map(|v| self.expression(v))
+                .chain(
+                    cells
+                        .iter()
+                        .flat_map(|v| v.iter().flat_map(|v| self.expression(v))),
+                )
+                .collect(),
+            Expression::Command => vec![LocationType::Command.spanned(e.span)],
+            Expression::Path(path) => self.expression(&path.head),
+            Expression::Variable(_, _) => vec![LocationType::Variable.spanned(e.span)],
+
+            Expression::Boolean(_)
+            | Expression::FilePath(_)
+            | Expression::Literal(Literal::ColumnPath(_))
+            | Expression::Literal(Literal::GlobPattern(_))
+            | Expression::Literal(Literal::Number(_))
+            | Expression::Literal(Literal::Size(_, _))
+            | Expression::Literal(Literal::String(_)) => {
+                vec![
+                    LocationType::Argument(self.command.clone(), self.flag.clone()).spanned(e.span),
+                ]
+            }
+
+            Expression::Binary(binary) => {
+                let mut result = Vec::new();
+                result.append(&mut self.expression(&binary.left));
+                result.append(&mut self.expression(&binary.right));
+                result
+            }
+            Expression::Range(range) => {
+                let mut result = Vec::new();
+                if let Some(left) = &range.left {
+                    result.append(&mut self.expression(left));
+                }
+                if let Some(right) = &range.right {
+                    result.append(&mut self.expression(right));
+                }
+                result
+            }
+
+            Expression::ExternalWord
+            | Expression::ExternalCommand(_)
+            | Expression::Synthetic(_)
+            | Expression::Literal(Literal::Operator(_))
+            | Expression::Literal(Literal::Bare(_))
+            | Expression::Garbage => Vec::new(),
+        }
+    }
+
+    fn internal_command(&self, internal: &InternalCommand) -> Vec<CompletionLocation> {
+        let mut result = Vec::new();
+
+        match internal.args.head.expr {
+            Expression::Command => {
+                result.push(LocationType::Command.spanned(internal.name_span));
+            }
+            Expression::Literal(Literal::String(_)) => {
+                result.push(LocationType::Command.spanned(internal.name_span));
+            }
+            _ => (),
+        }
+
+        if let Some(positionals) = &internal.args.positional {
+            let mut positionals = positionals.iter();
+
+            if internal.name == "run_external" {
+                if let Some(external_command) = positionals.next() {
+                    result.push(LocationType::Command.spanned(external_command.span));
+                }
+            }
+
+            result.extend(positionals.flat_map(|positional| match positional.expr {
+                Expression::Garbage => {
+                    let garbage = positional.span.slice(self.line);
+                    let location = if garbage.starts_with('-') {
+                        LocationType::Flag(internal.name.clone())
+                    } else {
+                        // TODO we may be able to map this to the name of a positional,
+                        //      but we'll need a signature
+                        LocationType::Argument(Some(internal.name.clone()), None)
+                    };
+
+                    vec![location.spanned(positional.span)]
+                }
+
+                _ => self.expression(positional),
+            }));
+        }
+
+        if let Some(named) = &internal.args.named {
+            for (name, kind) in &named.named {
+                match kind {
+                    NamedValue::PresentSwitch(span) => {
+                        result.push(LocationType::Flag(internal.name.clone()).spanned(*span));
+                    }
+
+                    NamedValue::Value(span, expr) => {
+                        result.push(LocationType::Flag(internal.name.clone()).spanned(*span));
+                        result.append(&mut self.with_flag(name.clone()).expression(expr));
+                    }
+
+                    _ => (),
+                }
+            }
+        }
+
+        result
+    }
+
+    fn pipeline(&self, pipeline: &Pipeline) -> Vec<CompletionLocation> {
+        let mut result = Vec::new();
+
+        for command in &pipeline.list {
+            match command {
+                ClassifiedCommand::Internal(internal) => {
+                    let engine = self.with_command(internal.name.clone());
+                    result.append(&mut engine.internal_command(internal));
+                }
+
+                ClassifiedCommand::Expr(expr) => result.append(&mut self.expression(expr)),
+                _ => (),
+            }
+        }
+
+        result
+    }
+
+    /// Flattens the block into a Vec of completion locations
+    pub fn completion_locations(&self, block: &Block) -> Vec<CompletionLocation> {
+        block
+            .block
+            .iter()
+            .flat_map(|g| g.pipelines.iter().flat_map(|v| self.pipeline(v)))
+            .collect()
+    }
+
+    pub fn new(line: &'s str) -> Flatten<'s> {
+        Flatten {
+            line,
+            command: None,
+            flag: None,
+        }
+    }
+
+    pub fn with_command(&self, command: String) -> Flatten<'s> {
+        Flatten {
+            line: self.line,
+            command: Some(command),
+            flag: None,
+        }
+    }
+
+    pub fn with_flag(&self, flag: String) -> Flatten<'s> {
+        Flatten {
+            line: self.line,
+            command: self.command.clone(),
+            flag: Some(flag),
+        }
+    }
+}
+
+/// Characters that precede a command name
+const BEFORE_COMMAND_CHARS: &[char] = &['|', '(', ';'];
+
+/// Determines the completion location for a given block at the given cursor position
+pub fn completion_location(line: &str, block: &Block, pos: usize) -> Vec<CompletionLocation> {
+    let completion_engine = Flatten::new(line);
+    let locations = completion_engine.completion_locations(block);
+
+    if locations.is_empty() {
+        vec![LocationType::Command.spanned(Span::unknown())]
+    } else {
+        let mut command = None;
+        let mut prev = None;
+        for loc in locations {
+            // We don't use span.contains because we want to include the end. This handles the case
+            // where the cursor is just after the text (i.e., no space between cursor and text)
+            if loc.span.start() <= pos && pos <= loc.span.end() {
+                // The parser sees the "-" in `cmd -` as an argument, but the user is likely
+                // expecting a flag.
+                return match loc.item {
+                    LocationType::Argument(ref cmd, _) => {
+                        if loc.span.slice(line) == "-" {
+                            let cmd = cmd.clone();
+                            let span = loc.span;
+                            vec![
+                                loc,
+                                LocationType::Flag(cmd.unwrap_or_default()).spanned(span),
+                            ]
+                        } else {
+                            vec![loc]
+                        }
+                    }
+                    _ => vec![loc],
+                };
+            } else if pos < loc.span.start() {
+                break;
+            }
+
+            if let LocationType::Command = loc.item {
+                command = Some(String::from(loc.span.slice(line)));
+            }
+
+            prev = Some(loc);
+        }
+
+        if let Some(prev) = prev {
+            // Cursor is between locations (or at the end). Look at the line to see if the cursor
+            // is after some character that would imply we're in the command position.
+            let start = prev.span.end();
+            if line[start..pos].contains(BEFORE_COMMAND_CHARS) {
+                vec![LocationType::Command.spanned(Span::new(pos, pos))]
+            } else {
+                // TODO this should be able to be mapped to a command
+                vec![LocationType::Argument(command, None).spanned(Span::new(pos, pos))]
+            }
+        } else {
+            // Cursor is before any possible completion location, so must be a command
+            vec![LocationType::Command.spanned(Span::unknown())]
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use nu_parser::{classify_block, lex, parse_block, ParserScope};
+    use nu_protocol::{Signature, SyntaxShape};
+
+    #[derive(Clone, Debug)]
+    struct VecRegistry(Vec<Signature>);
+
+    impl From<Vec<Signature>> for VecRegistry {
+        fn from(v: Vec<Signature>) -> Self {
+            VecRegistry(v)
+        }
+    }
+
+    impl ParserScope for VecRegistry {
+        fn has_signature(&self, name: &str) -> bool {
+            self.0.iter().any(|v| v.name == name)
+        }
+
+        fn get_signature(&self, name: &str) -> Option<nu_protocol::Signature> {
+            self.0.iter().find(|v| v.name == name).map(Clone::clone)
+        }
+
+        fn get_alias(&self, _name: &str) -> Option<Vec<Spanned<String>>> {
+            None
+        }
+
+        fn add_alias(&self, _name: &str, _replacement: Vec<Spanned<String>>) {
+            todo!()
+        }
+
+        fn add_definition(&self, _block: Block) {}
+
+        fn get_definitions(&self) -> Vec<Block> {
+            vec![]
+        }
+
+        fn enter_scope(&self) {}
+
+        fn exit_scope(&self) {}
+    }
+
+    mod completion_location {
+        use super::*;
+
+        use nu_parser::ParserScope;
+
+        fn completion_location(
+            line: &str,
+            scope: &dyn ParserScope,
+            pos: usize,
+        ) -> Vec<LocationType> {
+            let (tokens, _) = lex(line, 0);
+            let (lite_block, _) = parse_block(tokens);
+
+            scope.enter_scope();
+            let (block, _) = classify_block(&lite_block, scope);
+            scope.exit_scope();
+
+            super::completion_location(line, &block, pos)
+                .into_iter()
+                .map(|v| v.item)
+                .collect()
+        }
+
+        #[test]
+        fn completes_internal_command_names() {
+            let registry: VecRegistry =
+                vec![Signature::build("echo").rest(SyntaxShape::Any, "the values to echo")].into();
+            let line = "echo 1 | echo 2";
+
+            assert_eq!(
+                completion_location(line, &registry, 10),
+                vec![LocationType::Command],
+            );
+        }
+
+        #[test]
+        fn completes_external_command_names() {
+            let registry: VecRegistry = Vec::new().into();
+            let line = "echo 1 | echo 2";
+
+            assert_eq!(
+                completion_location(line, &registry, 10),
+                vec![LocationType::Command],
+            );
+        }
+
+        #[test]
+        fn completes_command_names_when_cursor_immediately_after_command_name() {
+            let registry: VecRegistry = Vec::new().into();
+            let line = "echo 1 | echo 2";
+
+            assert_eq!(
+                completion_location(line, &registry, 4),
+                vec![LocationType::Command],
+            );
+        }
+
+        #[test]
+        fn completes_variables() {
+            let registry: VecRegistry = Vec::new().into();
+            let line = "echo $nu.env.";
+
+            assert_eq!(
+                completion_location(line, &registry, 13),
+                vec![LocationType::Variable],
+            );
+        }
+
+        #[test]
+        fn completes_flags() {
+            let registry: VecRegistry = vec![Signature::build("du")
+                .switch("recursive", "the values to echo", None)
+                .rest(SyntaxShape::Any, "blah")]
+            .into();
+
+            let line = "du --recurs";
+
+            assert_eq!(
+                completion_location(line, &registry, 7),
+                vec![LocationType::Flag("du".to_string())],
+            );
+        }
+
+        #[test]
+        fn completes_incomplete_nested_structure() {
+            let registry: VecRegistry = vec![Signature::build("sys")].into();
+            let line = "echo $(sy";
+
+            assert_eq!(
+                completion_location(line, &registry, 8),
+                vec![LocationType::Command],
+            );
+        }
+
+        #[test]
+        fn has_correct_command_name_for_argument() {
+            let registry: VecRegistry = vec![Signature::build("cd")].into();
+            let line = "cd ";
+
+            assert_eq!(
+                completion_location(line, &registry, 3),
+                vec![LocationType::Argument(Some("cd".to_string()), None)],
+            );
+        }
+
+        #[test]
+        fn completes_flags_with_just_a_single_hyphen() {
+            let registry: VecRegistry = vec![Signature::build("du")
+                .switch("recursive", "the values to echo", None)
+                .rest(SyntaxShape::Any, "blah")]
+            .into();
+
+            let line = "du -";
+
+            assert_eq!(
+                completion_location(line, &registry, 3),
+                vec![
+                    LocationType::Argument(Some("du".to_string()), None),
+                    LocationType::Flag("du".to_string()),
+                ],
+            );
+        }
+
+        #[test]
+        fn completes_arguments() {
+            let registry: VecRegistry =
+                vec![Signature::build("echo").rest(SyntaxShape::Any, "the values to echo")].into();
+            let line = "echo 1 | echo 2";
+
+            assert_eq!(
+                completion_location(line, &registry, 6),
+                vec![LocationType::Argument(Some("echo".to_string()), None)],
+            );
+        }
+    }
+}

crates/nu-cli/src/completion/flag.rs

@@ -0,0 +1,41 @@
+use super::matchers::Matcher;
+use crate::completion::{Completer, CompletionContext, Suggestion};
+use nu_engine::EvaluationContext;
+
+pub struct FlagCompleter {
+    pub(crate) cmd: String,
+}
+
+impl Completer for FlagCompleter {
+    fn complete(
+        &self,
+        ctx: &CompletionContext<'_>,
+        partial: &str,
+        matcher: &dyn Matcher,
+    ) -> Vec<Suggestion> {
+        let context: &EvaluationContext = ctx.as_ref();
+
+        if let Some(cmd) = context.scope.get_command(&self.cmd) {
+            let sig = cmd.signature();
+            let mut suggestions = Vec::new();
+            for (name, (named_type, _desc)) in sig.named.iter() {
+                suggestions.push(format!("--{}", name));
+
+                if let Some(c) = named_type.get_short() {
+                    suggestions.push(format!("-{}", c));
+                }
+            }
+
+            suggestions
+                .into_iter()
+                .filter(|v| matcher.matches(partial, v))
+                .map(|v| Suggestion {
+                    replacement: format!("{} ", v),
+                    display: v,
+                })
+                .collect()
+        } else {
+            Vec::new()
+        }
+    }
+}

crates/nu-cli/src/completion/matchers/case_insensitive.rs

@@ -0,0 +1,45 @@
+use crate::completion::matchers;
+pub struct Matcher;
+
+impl matchers::Matcher for Matcher {
+    fn matches(&self, partial: &str, from: &str) -> bool {
+        from.to_ascii_lowercase()
+            .starts_with(partial.to_ascii_lowercase().as_str())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // TODO: check some unicode matches if this becomes relevant
+
+    // FIXME: could work exhaustively through ['-', '--'. ''] in a loop for each test
+    #[test]
+    fn completes_exact_matches() {
+        let matcher: Box<dyn matchers::Matcher> = Box::new(Matcher);
+
+        assert!(matcher.matches("shouldmatch", "shouldmatch"));
+        assert!(matcher.matches("shouldm", "shouldmatch"));
+        assert!(matcher.matches("--also-should-m", "--also-should-match"));
+        assert!(matcher.matches("-also-should-m", "-also-should-match"));
+    }
+
+    #[test]
+    fn completes_case_insensitive_matches() {
+        let matcher: Box<dyn matchers::Matcher> = Box::new(Matcher);
+
+        assert!(matcher.matches("thisshould", "Thisshouldmatch"));
+        assert!(matcher.matches("--Shouldm", "--shouldmatch"));
+        assert!(matcher.matches("-Shouldm", "-shouldmatch"));
+    }
+
+    #[test]
+    fn should_not_match_when_unequal() {
+        let matcher: Box<dyn matchers::Matcher> = Box::new(Matcher);
+
+        assert!(!matcher.matches("ashouldmatch", "Shouldnotmatch"));
+        assert!(!matcher.matches("--ashouldnotmatch", "--Shouldnotmatch"));
+        assert!(!matcher.matches("-ashouldnotmatch", "-Shouldnotmatch"));
+    }
+}

crates/nu-cli/src/completion/matchers/case_sensitive.rs

@@ -0,0 +1,28 @@
+use crate::completion::matchers;
+
+pub struct Matcher;
+
+impl matchers::Matcher for Matcher {
+    fn matches(&self, partial: &str, from: &str) -> bool {
+        from.starts_with(partial)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn completes_case_sensitive() {
+        let matcher: Box<dyn matchers::Matcher> = Box::new(Matcher);
+
+        //Should match
+        assert!(matcher.matches("shouldmatch", "shouldmatch"));
+        assert!(matcher.matches("shouldm", "shouldmatch"));
+        assert!(matcher.matches("--also-should-m", "--also-should-match"));
+        assert!(matcher.matches("-also-should-m", "-also-should-match"));
+
+        // Should not match
+        assert!(!matcher.matches("--Shouldnot", "--shouldnotmatch"));
+    }
+}

crates/nu-cli/src/completion/matchers/mod.rs

@@ -0,0 +1,6 @@
+pub(crate) mod case_insensitive;
+pub(crate) mod case_sensitive;
+
+pub trait Matcher {
+    fn matches(&self, partial: &str, from: &str) -> bool;
+}

crates/nu-cli/src/completion/mod.rs

@@ -0,0 +1,37 @@
+pub(crate) mod command;
+pub(crate) mod engine;
+pub(crate) mod flag;
+pub(crate) mod matchers;
+pub(crate) mod path;
+
+use matchers::Matcher;
+use nu_engine::EvaluationContext;
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct Suggestion {
+    pub display: String,
+    pub replacement: String,
+}
+
+pub struct CompletionContext<'a>(&'a EvaluationContext);
+
+impl<'a> CompletionContext<'a> {
+    pub fn new(a: &'a EvaluationContext) -> CompletionContext<'a> {
+        CompletionContext(a)
+    }
+}
+
+impl<'a> AsRef<EvaluationContext> for CompletionContext<'a> {
+    fn as_ref(&self) -> &EvaluationContext {
+        self.0
+    }
+}
+
+pub trait Completer {
+    fn complete(
+        &self,
+        ctx: &CompletionContext<'_>,
+        partial: &str,
+        matcher: &dyn Matcher,
+    ) -> Vec<Suggestion>;
+}

crates/nu-cli/src/completion/path.rs

@@ -0,0 +1,88 @@
+use std::path::PathBuf;
+
+use super::matchers::Matcher;
+use crate::completion::{Completer, CompletionContext, Suggestion};
+
+const SEP: char = std::path::MAIN_SEPARATOR;
+
+pub struct PathCompleter;
+
+pub struct PathSuggestion {
+    pub(crate) path: PathBuf,
+    pub(crate) suggestion: Suggestion,
+}
+
+impl PathCompleter {
+    pub fn path_suggestions(&self, partial: &str, matcher: &dyn Matcher) -> Vec<PathSuggestion> {
+        let expanded = nu_parser::expand_ndots(partial);
+        let expanded = expanded.as_ref();
+
+        let (base_dir_name, partial) = match expanded.rfind(SEP) {
+            Some(pos) => expanded.split_at(pos + SEP.len_utf8()),
+            None => ("", expanded),
+        };
+
+        let base_dir = if base_dir_name.is_empty() {
+            PathBuf::from(".")
+        } else {
+            #[cfg(feature = "directories")]
+            {
+                let home_prefix = format!("~{}", SEP);
+                if base_dir_name.starts_with(&home_prefix) {
+                    let mut home_dir = dirs_next::home_dir().unwrap_or_else(|| PathBuf::from("~"));
+                    home_dir.push(&base_dir_name[2..]);
+                    home_dir
+                } else {
+                    PathBuf::from(base_dir_name)
+                }
+            }
+            #[cfg(not(feature = "directories"))]
+            {
+                PathBuf::from(base_dir_name)
+            }
+        };
+
+        if let Ok(result) = base_dir.read_dir() {
+            result
+                .filter_map(|entry| {
+                    entry.ok().and_then(|entry| {
+                        let mut file_name = entry.file_name().to_string_lossy().into_owned();
+                        if matcher.matches(partial, file_name.as_str()) {
+                            let mut path = format!("{}{}", base_dir_name, file_name);
+                            if entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false) {
+                                path.push(std::path::MAIN_SEPARATOR);
+                                file_name.push(std::path::MAIN_SEPARATOR);
+                            }
+
+                            Some(PathSuggestion {
+                                path: entry.path(),
+                                suggestion: Suggestion {
+                                    replacement: path,
+                                    display: file_name,
+                                },
+                            })
+                        } else {
+                            None
+                        }
+                    })
+                })
+                .collect()
+        } else {
+            Vec::new()
+        }
+    }
+}
+
+impl Completer for PathCompleter {
+    fn complete(
+        &self,
+        _ctx: &CompletionContext<'_>,
+        partial: &str,
+        matcher: &dyn Matcher,
+    ) -> Vec<Suggestion> {
+        self.path_suggestions(partial, matcher)
+            .into_iter()
+            .map(|ps| ps.suggestion)
+            .collect()
+    }
+}

crates/nu-cli/src/env.rs

@@ -0,0 +1,3 @@
+pub(crate) mod directory_specific_environment;
+pub(crate) mod environment;
+pub(crate) mod environment_syncer;

crates/nu-cli/src/env/directory_specific_environment.rs

@@ -0,0 +1,259 @@
+use indexmap::{IndexMap, IndexSet};
+use nu_command::commands::autoenv;
+use nu_errors::ShellError;
+use serde::Deserialize;
+use std::env::*;
+use std::process::Command;
+
+use std::{
+    ffi::OsString,
+    fmt::Debug,
+    path::{Path, PathBuf},
+};
+
+//Tests reside in /nushell/tests/shell/pipeline/commands/internal.rs
+
+type EnvKey = String;
+type EnvVal = OsString;
+#[derive(Debug, Default)]
+pub struct DirectorySpecificEnvironment {
+    pub last_seen_directory: PathBuf,
+    //If an environment var has been added from a .nu in a directory, we track it here so we can remove it when the user leaves the directory.
+    //If setting the var overwrote some value, we save the old value in an option so we can restore it later.
+    added_vars: IndexMap<PathBuf, IndexMap<EnvKey, Option<EnvVal>>>,
+
+    //We track directories that we have read .nu-env from. This is different from the keys in added_vars since sometimes a file only wants to run scripts.
+    visited_dirs: IndexSet<PathBuf>,
+    exitscripts: IndexMap<PathBuf, Vec<String>>,
+}
+
+#[derive(Deserialize, Debug, Default)]
+pub struct NuEnvDoc {
+    pub env: Option<IndexMap<String, String>>,
+    pub scriptvars: Option<IndexMap<String, String>>,
+    pub scripts: Option<IndexMap<String, Vec<String>>>,
+    pub entryscripts: Option<Vec<String>>,
+    pub exitscripts: Option<Vec<String>>,
+}
+
+impl DirectorySpecificEnvironment {
+    pub fn new() -> DirectorySpecificEnvironment {
+        let root_dir = if cfg!(target_os = "windows") {
+            PathBuf::from("c:\\")
+        } else {
+            PathBuf::from("/")
+        };
+        DirectorySpecificEnvironment {
+            last_seen_directory: root_dir,
+            added_vars: IndexMap::new(),
+            visited_dirs: IndexSet::new(),
+            exitscripts: IndexMap::new(),
+        }
+    }
+
+    fn toml_if_trusted(&mut self, nu_env_file: &Path) -> Result<NuEnvDoc, ShellError> {
+        let content = std::fs::read(&nu_env_file)?;
+
+        if autoenv::file_is_trusted(&nu_env_file, &content)? {
+            let mut doc: NuEnvDoc = toml::de::from_slice(&content)
+                .map_err(|e| ShellError::untagged_runtime_error(format!("{:?}", e)))?;
+
+            if let Some(scripts) = doc.scripts.as_ref() {
+                for (k, v) in scripts {
+                    if k == "entryscripts" {
+                        doc.entryscripts = Some(v.clone());
+                    } else if k == "exitscripts" {
+                        doc.exitscripts = Some(v.clone());
+                    }
+                }
+            }
+            return Ok(doc);
+        }
+        Err(ShellError::untagged_runtime_error(
+                format!("{:?} is untrusted. Run 'autoenv trust {:?}' to trust it.\nThis needs to be done after each change to the file.", nu_env_file, nu_env_file.parent().unwrap_or_else(|| &Path::new("")))))
+    }
+
+    pub fn maintain_autoenv(&mut self) -> Result<(), ShellError> {
+        let mut dir = current_dir()?;
+
+        if self.last_seen_directory == dir {
+            return Ok(());
+        }
+
+        //We track which keys we set as we go up the directory hierarchy, so that we don't overwrite a value we set in a subdir.
+        let mut added_keys = IndexSet::new();
+
+        let mut new_visited_dirs = IndexSet::new();
+        let mut popped = true;
+        while popped {
+            let nu_env_file = dir.join(".nu-env");
+            if nu_env_file.exists() && !self.visited_dirs.contains(&dir) {
+                let nu_env_doc = self.toml_if_trusted(&nu_env_file)?;
+
+                //add regular variables from the [env section]
+                if let Some(env) = nu_env_doc.env {
+                    for (env_key, env_val) in env {
+                        self.maybe_add_key(&mut added_keys, &dir, &env_key, &env_val);
+                    }
+                }
+
+                //Add variables that need to evaluate scripts to run, from [scriptvars] section
+                if let Some(sv) = nu_env_doc.scriptvars {
+                    for (key, script) in sv {
+                        self.maybe_add_key(
+                            &mut added_keys,
+                            &dir,
+                            &key,
+                            value_from_script(&script)?.as_str(),
+                        );
+                    }
+                }
+
+                if let Some(es) = nu_env_doc.entryscripts {
+                    for s in es {
+                        run(s.as_str(), None)?;
+                    }
+                }
+
+                if let Some(es) = nu_env_doc.exitscripts {
+                    self.exitscripts.insert(dir.clone(), es);
+                }
+            }
+            new_visited_dirs.insert(dir.clone());
+            popped = dir.pop();
+        }
+
+        //Time to clear out vars set by directories that we have left.
+        let mut new_vars = IndexMap::new();
+        for (dir, dirmap) in self.added_vars.drain(..) {
+            if new_visited_dirs.contains(&dir) {
+                new_vars.insert(dir, dirmap);
+            } else {
+                for (k, v) in dirmap {
+                    if let Some(v) = v {
+                        std::env::set_var(k, v);
+                    } else {
+                        std::env::remove_var(k);
+                    }
+                }
+            }
+        }
+
+        //Run exitscripts, can not be done in same loop as new vars as some files can contain only exitscripts
+        let mut new_exitscripts = IndexMap::new();
+        for (dir, scripts) in self.exitscripts.drain(..) {
+            if new_visited_dirs.contains(&dir) {
+                new_exitscripts.insert(dir, scripts);
+            } else {
+                for s in scripts {
+                    run(s.as_str(), Some(&dir))?;
+                }
+            }
+        }
+
+        self.visited_dirs = new_visited_dirs;
+        self.exitscripts = new_exitscripts;
+        self.added_vars = new_vars;
+        self.last_seen_directory = current_dir()?;
+        Ok(())
+    }
+
+    pub fn maybe_add_key(
+        &mut self,
+        seen_vars: &mut IndexSet<EnvKey>,
+        dir: &Path,
+        key: &str,
+        val: &str,
+    ) {
+        //This condition is to make sure variables in parent directories don't overwrite variables set by subdirectories.
+        if !seen_vars.contains(key) {
+            seen_vars.insert(key.to_string());
+            self.added_vars
+                .entry(PathBuf::from(dir))
+                .or_insert(IndexMap::new())
+                .insert(key.to_string(), var_os(key));
+
+            std::env::set_var(key, val);
+        }
+    }
+
+    // If the user recently ran autoenv untrust on a file, we clear the environment variables it set and make sure to not run any possible exitscripts.
+    pub fn clear_recently_untrusted_file(&mut self) -> Result<(), ShellError> {
+        // Figure out which file was untrusted
+        // Remove all vars set by it
+        let current_trusted_files: IndexSet<PathBuf> = autoenv::read_trusted()?
+            .files
+            .iter()
+            .map(|(k, _)| PathBuf::from(k))
+            .collect();
+
+        // We figure out which file(s) the user untrusted by taking the set difference of current trusted files in .config/nu/nu-env.toml and the files tracked by self.added_env_vars
+        // If a file is in self.added_env_vars but not in nu-env.toml, it was just untrusted.
+        let untrusted_files: IndexSet<PathBuf> = self
+            .added_vars
+            .iter()
+            .filter_map(|(path, _)| {
+                if !current_trusted_files.contains(path) {
+                    return Some(path.clone());
+                }
+                None
+            })
+            .collect();
+
+        for path in untrusted_files {
+            if let Some(added_keys) = self.added_vars.get(&path) {
+                for (key, _) in added_keys {
+                    remove_var(key);
+                }
+            }
+            self.exitscripts.remove(&path);
+            self.added_vars.remove(&path);
+        }
+
+        Ok(())
+    }
+}
+
+fn run(cmd: &str, dir: Option<&PathBuf>) -> Result<(), ShellError> {
+    if cfg!(target_os = "windows") {
+        if let Some(dir) = dir {
+            let command = format!("cd {} & {}", dir.to_string_lossy(), cmd);
+            Command::new("cmd")
+                .args(&["/C", command.as_str()])
+                .output()?
+        } else {
+            Command::new("cmd").args(&["/C", cmd]).output()?
+        }
+    } else if let Some(dir) = dir {
+        // FIXME: When nu scripting is added, cding like might not be a good idea. If nu decides to execute entryscripts when entering the dir this way, it will cause troubles.
+        // For now only standard shell scripts are used, so this is an issue for the future.
+        Command::new("sh")
+            .arg("-c")
+            .arg(format!("cd {:?}; {}", dir, cmd))
+            .output()?
+    } else {
+        Command::new("sh").arg("-c").arg(&cmd).output()?
+    };
+    Ok(())
+}
+fn value_from_script(cmd: &str) -> Result<String, ShellError> {
+    let command = if cfg!(target_os = "windows") {
+        Command::new("cmd").args(&["/C", cmd]).output()?
+    } else {
+        Command::new("sh").arg("-c").arg(&cmd).output()?
+    };
+    if command.stdout.is_empty() {
+        return Err(ShellError::untagged_runtime_error(format!(
+            "{:?} did not return any output",
+            cmd
+        )));
+    }
+    let response = std::str::from_utf8(&command.stdout[..command.stdout.len()]).map_err(|e| {
+        ShellError::untagged_runtime_error(format!(
+            "Couldn't parse stdout from command {:?}: {:?}",
+            command, e
+        ))
+    })?;
+
+    Ok(response.trim().to_string())
+}

crates/nu-cli/src/env/environment.rs

@@ -0,0 +1,274 @@
+use crate::env::directory_specific_environment::*;
+use indexmap::{indexmap, IndexSet};
+use nu_data::config::Conf;
+use nu_engine::Env;
+use nu_errors::ShellError;
+use nu_protocol::{UntaggedValue, Value};
+
+#[derive(Debug, Default)]
+pub struct Environment {
+    environment_vars: Option<Value>,
+    path_vars: Option<Value>,
+    pub autoenv: DirectorySpecificEnvironment,
+}
+
+impl Environment {
+    pub fn new() -> Environment {
+        Environment {
+            environment_vars: None,
+            path_vars: None,
+            autoenv: DirectorySpecificEnvironment::new(),
+        }
+    }
+
+    pub fn from_config<T: Conf>(configuration: &T) -> Environment {
+        let env = configuration.env();
+        let path = configuration.path();
+        Environment {
+            environment_vars: env,
+            path_vars: path,
+            autoenv: DirectorySpecificEnvironment::new(),
+        }
+    }
+
+    pub fn autoenv(&mut self, reload_trusted: bool) -> Result<(), ShellError> {
+        self.autoenv.maintain_autoenv()?;
+        if reload_trusted {
+            self.autoenv.clear_recently_untrusted_file()?;
+        }
+        Ok(())
+    }
+
+    pub fn morph<T: Conf>(&mut self, configuration: &T) {
+        self.environment_vars = configuration.env();
+        self.path_vars = configuration.path();
+    }
+}
+
+impl Env for Environment {
+    fn env(&self) -> Option<Value> {
+        if let Some(vars) = &self.environment_vars {
+            return Some(vars.clone());
+        }
+
+        None
+    }
+
+    fn path(&self) -> Option<Value> {
+        if let Some(vars) = &self.path_vars {
+            return Some(vars.clone());
+        }
+
+        None
+    }
+
+    fn add_env(&mut self, key: &str, value: &str) {
+        let value = UntaggedValue::string(value);
+
+        let new_envs = {
+            if let Some(Value {
+                value: UntaggedValue::Row(ref envs),
+                ref tag,
+            }) = self.environment_vars
+            {
+                let mut new_envs = envs.clone();
+
+                if !new_envs.contains_key(key) {
+                    new_envs.insert_data_at_key(key, value.into_value(tag.clone()));
+                }
+
+                Value {
+                    value: UntaggedValue::Row(new_envs),
+                    tag: tag.clone(),
+                }
+            } else {
+                UntaggedValue::Row(indexmap! { key.into() => value.into_untagged_value() }.into())
+                    .into_untagged_value()
+            }
+        };
+
+        self.environment_vars = Some(new_envs);
+    }
+
+    fn add_path(&mut self, paths: std::ffi::OsString) {
+        let new_paths = {
+            if let Some(Value {
+                value: UntaggedValue::Table(ref current_paths),
+                ref tag,
+            }) = self.path_vars
+            {
+                let mut new_paths = current_paths.clone();
+
+                let new_path_candidates = std::env::split_paths(&paths).map(|path| {
+                    UntaggedValue::string(path.to_string_lossy()).into_value(tag.clone())
+                });
+
+                new_paths.extend(new_path_candidates);
+
+                let paths: IndexSet<Value> = new_paths.into_iter().collect();
+
+                Value {
+                    value: UntaggedValue::Table(paths.into_iter().collect()),
+                    tag: tag.clone(),
+                }
+            } else {
+                let p = paths.into_string().unwrap_or_else(|_| String::from(""));
+                let p = UntaggedValue::string(p).into_untagged_value();
+                UntaggedValue::Table(vec![p]).into_untagged_value()
+            }
+        };
+
+        self.path_vars = Some(new_paths);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Env, Environment};
+    use nu_data::config::{tests::FakeConfig, Conf};
+    use nu_protocol::UntaggedValue;
+    use nu_test_support::fs::Stub::FileWithContent;
+    use nu_test_support::playground::Playground;
+
+    #[test]
+    fn picks_up_environment_variables_from_configuration() {
+        Playground::setup("environment_test_1", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    [env]
+                    mosquetero_1 = "Andrés N. Robalino"
+                    mosquetero_2 = "Jonathan Turner"
+                    mosquetero_3 = "Yehuda katz"
+                    mosquetero_4 = "Jason Gedge"
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let actual = Environment::from_config(&fake_config);
+
+            assert_eq!(actual.env(), fake_config.env());
+        });
+    }
+
+    #[test]
+    fn picks_up_path_variables_from_configuration() {
+        Playground::setup("environment_test_2", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    path = ["/Users/andresrobalino/.volta/bin", "/users/mosqueteros/bin"]
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let actual = Environment::from_config(&fake_config);
+
+            assert_eq!(actual.path(), fake_config.path());
+        });
+    }
+
+    #[test]
+    fn updates_env_variable() {
+        Playground::setup("environment_test_3", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    [env]
+                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = Environment::from_config(&fake_config);
+
+            actual.add_env("USER", "NUNO");
+
+            assert_eq!(
+                actual.env(),
+                Some(
+                    UntaggedValue::row(
+                        indexmap! {
+                            "USER".into() => UntaggedValue::string("NUNO").into_untagged_value(),
+                            "SHELL".into() => UntaggedValue::string("/usr/bin/you_already_made_the_nu_choice").into_untagged_value(),
+                        }
+                    ).into_untagged_value()
+                )
+            );
+        });
+    }
+
+    #[test]
+    fn does_not_update_env_variable_if_it_exists() {
+        Playground::setup("environment_test_4", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    [env]
+                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = Environment::from_config(&fake_config);
+
+            actual.add_env("SHELL", "/usr/bin/sh");
+
+            assert_eq!(
+                actual.env(),
+                Some(
+                    UntaggedValue::row(
+                        indexmap! {
+                            "SHELL".into() => UntaggedValue::string("/usr/bin/you_already_made_the_nu_choice").into_untagged_value(),
+                        }
+                    ).into_untagged_value()
+                )
+            );
+        });
+    }
+
+    #[test]
+    fn updates_path_variable() {
+        Playground::setup("environment_test_5", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    path = ["/Users/andresrobalino/.volta/bin", "/users/mosqueteros/bin"]
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = Environment::from_config(&fake_config);
+
+            actual.add_path(std::ffi::OsString::from("/path/to/be/added"));
+
+            assert_eq!(
+                actual.path(),
+                Some(
+                    UntaggedValue::table(&[
+                        UntaggedValue::string("/Users/andresrobalino/.volta/bin")
+                            .into_untagged_value(),
+                        UntaggedValue::string("/users/mosqueteros/bin").into_untagged_value(),
+                        UntaggedValue::string("/path/to/be/added").into_untagged_value(),
+                    ])
+                    .into_untagged_value()
+                )
+            );
+        });
+    }
+}

crates/nu-cli/src/env/environment_syncer.rs

@@ -0,0 +1,617 @@
+use crate::env::environment::Environment;
+use nu_data::config::{Conf, NuConfig};
+use nu_engine::Env;
+use nu_engine::EvaluationContext;
+use nu_errors::ShellError;
+use parking_lot::Mutex;
+use std::sync::{atomic::Ordering, Arc};
+
+pub struct EnvironmentSyncer {
+    pub env: Arc<Mutex<Box<Environment>>>,
+    pub config: Arc<Mutex<Box<dyn Conf>>>,
+}
+
+impl Default for EnvironmentSyncer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl EnvironmentSyncer {
+    pub fn with_config(config: Box<dyn Conf>) -> Self {
+        EnvironmentSyncer {
+            env: Arc::new(Mutex::new(Box::new(Environment::new()))),
+            config: Arc::new(Mutex::new(config)),
+        }
+    }
+
+    pub fn new() -> EnvironmentSyncer {
+        EnvironmentSyncer {
+            env: Arc::new(Mutex::new(Box::new(Environment::new()))),
+            config: Arc::new(Mutex::new(Box::new(NuConfig::new()))),
+        }
+    }
+
+    #[cfg(test)]
+    pub fn set_config(&mut self, config: Box<dyn Conf>) {
+        self.config = Arc::new(Mutex::new(config));
+    }
+
+    pub fn get_config(&self) -> Box<dyn Conf> {
+        let config = self.config.lock();
+
+        config.clone_box()
+    }
+
+    pub fn load_environment(&mut self) {
+        let config = self.config.lock();
+
+        self.env = Arc::new(Mutex::new(Box::new(Environment::from_config(&*config))));
+    }
+
+    pub fn did_config_change(&mut self) -> bool {
+        let config = self.config.lock();
+        config.is_modified().unwrap_or(false)
+    }
+
+    pub fn reload(&mut self) {
+        let mut config = self.config.lock();
+        config.reload();
+
+        let mut environment = self.env.lock();
+        environment.morph(&*config);
+    }
+
+    pub fn autoenv(&self, ctx: &mut EvaluationContext) -> Result<(), ShellError> {
+        let mut environment = self.env.lock();
+        let recently_used = ctx
+            .user_recently_used_autoenv_untrust
+            .load(Ordering::SeqCst);
+        let auto = environment.autoenv(recently_used);
+        ctx.user_recently_used_autoenv_untrust
+            .store(false, Ordering::SeqCst);
+        auto
+    }
+
+    pub fn sync_env_vars(&mut self, ctx: &mut EvaluationContext) {
+        let mut environment = self.env.lock();
+
+        if environment.env().is_some() {
+            for (name, value) in ctx.with_host(|host| host.vars()) {
+                if name != "path" && name != "PATH" {
+                    // account for new env vars present in the current session
+                    // that aren't loaded from config.
+                    environment.add_env(&name, &value);
+
+                    // clear the env var from the session
+                    // we are about to replace them
+                    ctx.with_host(|host| host.env_rm(std::ffi::OsString::from(name)));
+                }
+            }
+
+            if let Some(variables) = environment.env() {
+                for var in variables.row_entries() {
+                    if let Ok(string) = var.1.as_string() {
+                        ctx.with_host(|host| {
+                            host.env_set(
+                                std::ffi::OsString::from(var.0),
+                                std::ffi::OsString::from(&string),
+                            )
+                        });
+
+                        ctx.scope.add_env_var_to_base(var.0, string);
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn sync_path_vars(&mut self, ctx: &mut EvaluationContext) {
+        let mut environment = self.env.lock();
+
+        if environment.path().is_some() {
+            let native_paths = ctx.with_host(|host| host.env_get(std::ffi::OsString::from("PATH")));
+
+            if let Some(native_paths) = native_paths {
+                environment.add_path(native_paths);
+
+                ctx.with_host(|host| {
+                    host.env_rm(std::ffi::OsString::from("PATH"));
+                });
+            }
+
+            if let Some(new_paths) = environment.path() {
+                let prepared = std::env::join_paths(
+                    new_paths
+                        .table_entries()
+                        .map(|p| p.as_string())
+                        .filter_map(Result::ok),
+                );
+
+                if let Ok(paths_ready) = prepared {
+                    ctx.with_host(|host| {
+                        host.env_set(
+                            std::ffi::OsString::from("PATH"),
+                            std::ffi::OsString::from(&paths_ready),
+                        );
+                    });
+
+                    ctx.scope
+                        .add_env_var_to_base("PATH", paths_ready.to_string_lossy().to_string());
+                }
+            }
+        }
+    }
+
+    #[cfg(test)]
+    pub fn clear_env_vars(&mut self, ctx: &mut EvaluationContext) {
+        for (key, _value) in ctx.with_host(|host| host.vars()) {
+            if key != "path" && key != "PATH" {
+                ctx.with_host(|host| host.env_rm(std::ffi::OsString::from(key)));
+            }
+        }
+    }
+
+    #[cfg(test)]
+    pub fn clear_path_var(&mut self, ctx: &mut EvaluationContext) {
+        ctx.with_host(|host| host.env_rm(std::ffi::OsString::from("PATH")));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EnvironmentSyncer;
+    use indexmap::IndexMap;
+    use nu_data::config::tests::FakeConfig;
+    use nu_engine::basic_evaluation_context;
+    use nu_engine::Env;
+    use nu_errors::ShellError;
+    use nu_test_support::fs::Stub::FileWithContent;
+    use nu_test_support::playground::Playground;
+    use parking_lot::Mutex;
+    use std::path::PathBuf;
+    use std::sync::Arc;
+
+    // This test fails on Linux.
+    // It's possible it has something to do with the fake configuration
+    // TODO: More tests.
+    #[cfg(not(target_os = "linux"))]
+    #[test]
+    fn syncs_env_if_new_env_entry_is_added_to_an_existing_configuration() -> Result<(), ShellError>
+    {
+        let mut ctx = basic_evaluation_context()?;
+        ctx.host = Arc::new(Mutex::new(Box::new(nu_engine::FakeHost::new())));
+
+        let mut expected = IndexMap::new();
+        expected.insert(
+            "SHELL".to_string(),
+            "/usr/bin/you_already_made_the_nu_choice".to_string(),
+        );
+
+        Playground::setup("syncs_env_from_config_updated_test_1", |dirs, sandbox| {
+            sandbox.with_files(vec![
+                FileWithContent(
+                    "configuration.toml",
+                    r#"
+                    [env]
+                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
+                "#,
+                ),
+                FileWithContent(
+                    "updated_configuration.toml",
+                    r#"
+                    [env]
+                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
+                    USER = "NUNO"
+                "#,
+                ),
+            ]);
+
+            let file = dirs.test().join("configuration.toml");
+            let new_file = dirs.test().join("updated_configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = EnvironmentSyncer::with_config(Box::new(fake_config));
+
+            // Here, the environment variables from the current session
+            // are cleared since we will load and set them from the
+            // configuration file
+            actual.clear_env_vars(&mut ctx);
+
+            // Nu loads the environment variables from the configuration file
+            actual.load_environment();
+            actual.sync_env_vars(&mut ctx);
+
+            {
+                let environment = actual.env.lock();
+                let mut vars = IndexMap::new();
+                environment
+                    .env()
+                    .expect("No variables in the environment.")
+                    .row_entries()
+                    .for_each(|(name, value)| {
+                        vars.insert(
+                            name.to_string(),
+                            value.as_string().expect("Couldn't convert to string"),
+                        );
+                    });
+
+                for k in expected.keys() {
+                    assert!(vars.contains_key(k));
+                }
+            }
+
+            assert!(!actual.did_config_change());
+
+            // Replacing the newer configuration file to the existing one.
+            let new_config_contents = std::fs::read_to_string(new_file).expect("Failed");
+            std::fs::write(&file, &new_config_contents).expect("Failed");
+
+            // A change has happened
+            assert!(actual.did_config_change());
+
+            // Syncer should reload and add new envs
+            actual.reload();
+            actual.sync_env_vars(&mut ctx);
+
+            expected.insert("USER".to_string(), "NUNO".to_string());
+
+            {
+                let environment = actual.env.lock();
+                let mut vars = IndexMap::new();
+                environment
+                    .env()
+                    .expect("No variables in the environment.")
+                    .row_entries()
+                    .for_each(|(name, value)| {
+                        vars.insert(
+                            name.to_string(),
+                            value.as_string().expect("Couldn't convert to string"),
+                        );
+                    });
+
+                for k in expected.keys() {
+                    assert!(vars.contains_key(k));
+                }
+            }
+        });
+
+        Ok(())
+    }
+
+    #[test]
+    fn syncs_env_if_new_env_entry_in_session_is_not_in_configuration_file() -> Result<(), ShellError>
+    {
+        let mut ctx = basic_evaluation_context()?;
+        ctx.host = Arc::new(Mutex::new(Box::new(nu_engine::FakeHost::new())));
+
+        let mut expected = IndexMap::new();
+        expected.insert(
+            "SHELL".to_string(),
+            "/usr/bin/you_already_made_the_nu_choice".to_string(),
+        );
+        expected.insert("USER".to_string(), "NUNO".to_string());
+
+        Playground::setup("syncs_env_test_1", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    [env]
+                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = EnvironmentSyncer::new();
+            actual.set_config(Box::new(fake_config));
+
+            // Here, the environment variables from the current session
+            // are cleared since we will load and set them from the
+            // configuration file (if any)
+            actual.clear_env_vars(&mut ctx);
+
+            // We explicitly simulate and add the USER variable to the current
+            // session's environment variables with the value "NUNO".
+            ctx.with_host(|test_host| {
+                test_host.env_set(
+                    std::ffi::OsString::from("USER"),
+                    std::ffi::OsString::from("NUNO"),
+                )
+            });
+
+            // Nu loads the environment variables from the configuration file (if any)
+            actual.load_environment();
+
+            // By this point, Nu has already loaded the environment variables
+            // stored in the configuration file. Before continuing we check
+            // if any new environment variables have been added from the ones loaded
+            // in the configuration file.
+            //
+            // Nu sees the missing "USER" variable and accounts for it.
+            actual.sync_env_vars(&mut ctx);
+
+            // Confirms session environment variables are replaced from Nu configuration file
+            // including the newer one accounted for.
+            ctx.with_host(|test_host| {
+                let var_user = test_host
+                    .env_get(std::ffi::OsString::from("USER"))
+                    .expect("Couldn't get USER var from host.")
+                    .into_string()
+                    .expect("Couldn't convert to string.");
+
+                let var_shell = test_host
+                    .env_get(std::ffi::OsString::from("SHELL"))
+                    .expect("Couldn't get SHELL var from host.")
+                    .into_string()
+                    .expect("Couldn't convert to string.");
+
+                let mut found = IndexMap::new();
+                found.insert("SHELL".to_string(), var_shell);
+                found.insert("USER".to_string(), var_user);
+
+                for k in found.keys() {
+                    assert!(expected.contains_key(k));
+                }
+            });
+
+            // Now confirm in-memory environment variables synced appropriately
+            // including the newer one accounted for.
+            let environment = actual.env.lock();
+
+            let mut vars = IndexMap::new();
+            environment
+                .env()
+                .expect("No variables in the environment.")
+                .row_entries()
+                .for_each(|(name, value)| {
+                    vars.insert(
+                        name.to_string(),
+                        value.as_string().expect("Couldn't convert to string"),
+                    );
+                });
+            for k in expected.keys() {
+                assert!(vars.contains_key(k));
+            }
+        });
+        Ok(())
+    }
+
+    #[test]
+    fn nu_envs_have_higher_priority_and_does_not_get_overwritten() -> Result<(), ShellError> {
+        let mut ctx = basic_evaluation_context()?;
+        ctx.host = Arc::new(Mutex::new(Box::new(nu_engine::FakeHost::new())));
+
+        let mut expected = IndexMap::new();
+        expected.insert(
+            "SHELL".to_string(),
+            "/usr/bin/you_already_made_the_nu_choice".to_string(),
+        );
+
+        Playground::setup("syncs_env_test_2", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    [env]
+                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = EnvironmentSyncer::new();
+            actual.set_config(Box::new(fake_config));
+
+            actual.clear_env_vars(&mut ctx);
+
+            ctx.with_host(|test_host| {
+                test_host.env_set(
+                    std::ffi::OsString::from("SHELL"),
+                    std::ffi::OsString::from("/usr/bin/sh"),
+                )
+            });
+
+            actual.load_environment();
+            actual.sync_env_vars(&mut ctx);
+
+            ctx.with_host(|test_host| {
+                let var_shell = test_host
+                    .env_get(std::ffi::OsString::from("SHELL"))
+                    .expect("Couldn't get SHELL var from host.")
+                    .into_string()
+                    .expect("Couldn't convert to string.");
+
+                let mut found = IndexMap::new();
+                found.insert("SHELL".to_string(), var_shell);
+
+                for k in found.keys() {
+                    assert!(expected.contains_key(k));
+                }
+            });
+
+            let environment = actual.env.lock();
+
+            let mut vars = IndexMap::new();
+            environment
+                .env()
+                .expect("No variables in the environment.")
+                .row_entries()
+                .for_each(|(name, value)| {
+                    vars.insert(
+                        name.to_string(),
+                        value.as_string().expect("couldn't convert to string"),
+                    );
+                });
+            for k in expected.keys() {
+                assert!(vars.contains_key(k));
+            }
+        });
+
+        Ok(())
+    }
+
+    #[test]
+    fn syncs_path_if_new_path_entry_in_session_is_not_in_configuration_file(
+    ) -> Result<(), ShellError> {
+        let mut ctx = basic_evaluation_context()?;
+        ctx.host = Arc::new(Mutex::new(Box::new(nu_engine::FakeHost::new())));
+
+        let expected = std::env::join_paths(vec![
+            PathBuf::from("/Users/andresrobalino/.volta/bin"),
+            PathBuf::from("/Users/mosqueteros/bin"),
+            PathBuf::from("/path/to/be/added"),
+        ])
+        .expect("Couldn't join paths.")
+        .into_string()
+        .expect("Couldn't convert to string.");
+
+        Playground::setup("syncs_path_test_1", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    path = ["/Users/andresrobalino/.volta/bin", "/Users/mosqueteros/bin"]
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = EnvironmentSyncer::new();
+            actual.set_config(Box::new(fake_config));
+
+            // Here, the environment variables from the current session
+            // are cleared since we will load and set them from the
+            // configuration file (if any)
+            actual.clear_path_var(&mut ctx);
+
+            // We explicitly simulate and add the PATH variable to the current
+            // session with the path "/path/to/be/added".
+            ctx.with_host(|test_host| {
+                test_host.env_set(
+                    std::ffi::OsString::from("PATH"),
+                    std::env::join_paths(vec![PathBuf::from("/path/to/be/added")])
+                        .expect("Couldn't join paths."),
+                )
+            });
+
+            // Nu loads the path variables from the configuration file (if any)
+            actual.load_environment();
+
+            // By this point, Nu has already loaded environment path variable
+            // stored in the configuration file. Before continuing we check
+            // if any new paths have been added from the ones loaded in the
+            // configuration file.
+            //
+            // Nu sees the missing "/path/to/be/added" and accounts for it.
+            actual.sync_path_vars(&mut ctx);
+
+            ctx.with_host(|test_host| {
+                let actual = test_host
+                    .env_get(std::ffi::OsString::from("PATH"))
+                    .expect("Couldn't get PATH var from host.")
+                    .into_string()
+                    .expect("Couldn't convert to string.");
+
+                assert_eq!(actual, expected);
+            });
+
+            let environment = actual.env.lock();
+
+            let paths = std::env::join_paths(
+                &environment
+                    .path()
+                    .expect("No path variable in the environment.")
+                    .table_entries()
+                    .map(|value| value.as_string().expect("Couldn't convert to string"))
+                    .map(PathBuf::from)
+                    .collect::<Vec<_>>(),
+            )
+            .expect("Couldn't join paths.")
+            .into_string()
+            .expect("Couldn't convert to string.");
+
+            assert_eq!(paths, expected);
+        });
+
+        Ok(())
+    }
+
+    #[test]
+    fn nu_paths_have_higher_priority_and_new_paths_get_appended_to_the_end(
+    ) -> Result<(), ShellError> {
+        let mut ctx = basic_evaluation_context()?;
+        ctx.host = Arc::new(Mutex::new(Box::new(nu_engine::FakeHost::new())));
+
+        let expected = std::env::join_paths(vec![
+            PathBuf::from("/Users/andresrobalino/.volta/bin"),
+            PathBuf::from("/Users/mosqueteros/bin"),
+            PathBuf::from("/path/to/be/added"),
+        ])
+        .expect("Couldn't join paths.")
+        .into_string()
+        .expect("Couldn't convert to string.");
+
+        Playground::setup("syncs_path_test_2", |dirs, sandbox| {
+            sandbox.with_files(vec![FileWithContent(
+                "configuration.toml",
+                r#"
+                    path = ["/Users/andresrobalino/.volta/bin", "/Users/mosqueteros/bin"]
+                "#,
+            )]);
+
+            let mut file = dirs.test().clone();
+            file.push("configuration.toml");
+
+            let fake_config = FakeConfig::new(&file);
+            let mut actual = EnvironmentSyncer::new();
+            actual.set_config(Box::new(fake_config));
+
+            actual.clear_path_var(&mut ctx);
+
+            ctx.with_host(|test_host| {
+                test_host.env_set(
+                    std::ffi::OsString::from("PATH"),
+                    std::env::join_paths(vec![PathBuf::from("/path/to/be/added")])
+                        .expect("Couldn't join paths."),
+                )
+            });
+
+            actual.load_environment();
+            actual.sync_path_vars(&mut ctx);
+
+            ctx.with_host(|test_host| {
+                let actual = test_host
+                    .env_get(std::ffi::OsString::from("PATH"))
+                    .expect("Couldn't get PATH var from host.")
+                    .into_string()
+                    .expect("Couldn't convert to string.");
+
+                assert_eq!(actual, expected);
+            });
+
+            let environment = actual.env.lock();
+
+            let paths = std::env::join_paths(
+                &environment
+                    .path()
+                    .expect("No path variable in the environment.")
+                    .table_entries()
+                    .map(|value| value.as_string().expect("Couldn't convert to string"))
+                    .map(PathBuf::from)
+                    .collect::<Vec<_>>(),
+            )
+            .expect("Couldn't join paths.")
+            .into_string()
+            .expect("Couldn't convert to string.");
+
+            assert_eq!(paths, expected);
+        });
+
+        Ok(())
+    }
+}

crates/nu-cli/src/format.rs

@@ -0,0 +1,6 @@
+use crate::prelude::*;
+use nu_errors::ShellError;
+
+pub(crate) trait RenderView {
+    fn render_view(&self, host: &mut dyn Host) -> Result<(), ShellError>;
+}

crates/nu-cli/src/keybinding.rs

@@ -0,0 +1,426 @@
+use serde::{Deserialize, Serialize};
+
+fn convert_keypress(keypress: KeyPress) -> rustyline::KeyPress {
+    match keypress {
+        KeyPress::UnknownEscSeq => rustyline::KeyPress::UnknownEscSeq,
+        KeyPress::Backspace => rustyline::KeyPress::Backspace,
+        KeyPress::BackTab => rustyline::KeyPress::BackTab,
+        KeyPress::BracketedPasteStart => rustyline::KeyPress::BracketedPasteStart,
+        KeyPress::BracketedPasteEnd => rustyline::KeyPress::BracketedPasteEnd,
+        KeyPress::Char(c) => rustyline::KeyPress::Char(c),
+        KeyPress::ControlDown => rustyline::KeyPress::ControlDown,
+        KeyPress::ControlLeft => rustyline::KeyPress::ControlLeft,
+        KeyPress::ControlRight => rustyline::KeyPress::ControlRight,
+        KeyPress::ControlUp => rustyline::KeyPress::ControlUp,
+        KeyPress::Ctrl(c) => rustyline::KeyPress::Ctrl(c),
+        KeyPress::Delete => rustyline::KeyPress::Delete,
+        KeyPress::Down => rustyline::KeyPress::Down,
+        KeyPress::End => rustyline::KeyPress::End,
+        KeyPress::Enter => rustyline::KeyPress::Enter,
+        KeyPress::Esc => rustyline::KeyPress::Esc,
+        KeyPress::F(u) => rustyline::KeyPress::F(u),
+        KeyPress::Home => rustyline::KeyPress::Home,
+        KeyPress::Insert => rustyline::KeyPress::Insert,
+        KeyPress::Left => rustyline::KeyPress::Left,
+        KeyPress::Meta(c) => rustyline::KeyPress::Meta(c),
+        KeyPress::Null => rustyline::KeyPress::Null,
+        KeyPress::PageDown => rustyline::KeyPress::PageDown,
+        KeyPress::PageUp => rustyline::KeyPress::PageUp,
+        KeyPress::Right => rustyline::KeyPress::Right,
+        KeyPress::ShiftDown => rustyline::KeyPress::ShiftDown,
+        KeyPress::ShiftLeft => rustyline::KeyPress::ShiftLeft,
+        KeyPress::ShiftRight => rustyline::KeyPress::ShiftRight,
+        KeyPress::ShiftUp => rustyline::KeyPress::ShiftUp,
+        KeyPress::Tab => rustyline::KeyPress::Tab,
+        KeyPress::Up => rustyline::KeyPress::Up,
+    }
+}
+
+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,
+        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::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::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::Noop => rustyline::Cmd::Noop,
+        Cmd::Overwrite(c) => rustyline::Cmd::Overwrite(c),
+        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::KeyPress, rustyline::Cmd) {
+    (
+        convert_keypress(keybinding.key),
+        convert_cmd(keybinding.binding),
+    )
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum KeyPress {
+    /// Unsupported escape sequence (on unix platform)
+    UnknownEscSeq,
+    /// ⌫ or `KeyPress::Ctrl('H')`
+    Backspace,
+    /// ⇤ (usually Shift-Tab)
+    BackTab,
+    /// Paste (on unix platform)
+    BracketedPasteStart,
+    /// Paste (on unix platform)
+    BracketedPasteEnd,
+    /// Single char
+    Char(char),
+    /// Ctrl-↓
+    ControlDown,
+    /// Ctrl-←
+    ControlLeft,
+    /// Ctrl-→
+    ControlRight,
+    /// Ctrl-↑
+    ControlUp,
+    /// Ctrl-char
+    Ctrl(char),
+    /// ⌦
+    Delete,
+    /// ↓ arrow key
+    Down,
+    /// ⇲
+    End,
+    /// ↵ or `KeyPress::Ctrl('M')`
+    Enter,
+    /// Escape or `KeyPress::Ctrl('[')`
+    Esc,
+    /// Function key
+    F(u8),
+    /// ⇱
+    Home,
+    /// Insert key
+    Insert,
+    /// ← arrow key
+    Left,
+    /// Escape-char or Alt-char
+    Meta(char),
+    /// `KeyPress::Char('\0')`
+    Null,
+    /// ⇟
+    PageDown,
+    /// ⇞
+    PageUp,
+    /// → arrow key
+    Right,
+    /// Shift-↓
+    ShiftDown,
+    /// Shift-←
+    ShiftLeft,
+    /// Shift-→
+    ShiftRight,
+    /// Shift-↑
+    ShiftUp,
+    /// ⇥ or `KeyPress::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,
+    /// downcase-word
+    DowncaseWord,
+    /// vi-eof-maybe
+    EndOfFile,
+    /// end-of-history
+    EndOfHistory,
+    /// forward-search-history
+    ForwardSearchHistory,
+    /// history-search-backward
+    HistorySearchBackward,
+    /// history-search-forward
+    HistorySearchForward,
+    /// 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),
+    /// next-history
+    NextHistory,
+    /// No action
+    Noop,
+    /// vi-replace
+    Overwrite(char),
+    /// 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 number of times one command should be repeated.
+pub type RepeatCount = usize;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Keybinding {
+    key: KeyPress,
+    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)?;
+
+        for keybinding in keybindings.into_iter() {
+            let (k, b) = convert_keybinding(keybinding);
+
+            rl.bind_sequence(k, b);
+        }
+    }
+
+    Ok(())
+}

crates/nu-cli/src/lib.rs

@@ -0,0 +1,43 @@
+#![recursion_limit = "2048"]
+
+#[cfg(test)]
+#[macro_use]
+extern crate indexmap;
+
+#[macro_use]
+mod prelude;
+
+#[cfg(test)]
+extern crate quickcheck;
+#[cfg(test)]
+#[macro_use(quickcheck)]
+extern crate quickcheck_macros;
+
+mod cli;
+#[cfg(feature = "rustyline-support")]
+mod completion;
+mod env;
+mod format;
+#[cfg(feature = "rustyline-support")]
+mod keybinding;
+mod line_editor;
+mod shell;
+pub mod types;
+
+#[cfg(feature = "rustyline-support")]
+pub use crate::cli::cli;
+
+pub use crate::cli::{parse_and_eval, register_plugins, run_script_file};
+
+pub use crate::env::environment_syncer::EnvironmentSyncer;
+pub use nu_command::commands::default_context::create_default_context;
+pub use nu_data::config;
+pub use nu_data::dict::TaggedListBuilder;
+pub use nu_data::primitive;
+pub use nu_data::value;
+pub use nu_stream::{InputStream, InterruptibleStream, OutputStream};
+pub use nu_value_ext::ValueExt;
+pub use num_traits::cast::ToPrimitive;
+
+// TODO: Temporary redirect
+pub use nu_protocol::{did_you_mean, TaggedDictBuilder};

crates/nu-cli/src/line_editor.rs

@@ -0,0 +1,234 @@
+use nu_engine::EvaluationContext;
+use std::error::Error;
+
+#[allow(unused_imports)]
+use crate::prelude::*;
+
+#[allow(unused_imports)]
+use nu_command::script::LineResult;
+
+#[cfg(feature = "rustyline-support")]
+use crate::shell::Helper;
+
+#[cfg(feature = "rustyline-support")]
+use rustyline::{
+    self,
+    config::Configurer,
+    config::{ColorMode, CompletionType, Config},
+    error::ReadlineError,
+    At, Cmd, Editor, KeyPress, 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) => {
+            outln!("Error: {:?}", err);
+            LineResult::Break
+        }
+    }
+}
+
+#[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().color_mode(ColorMode::Forced).build();
+    let mut rl: Editor<_> = Editor::with_config(config);
+
+    // add key bindings to move over a whole word with Ctrl+ArrowLeft and Ctrl+ArrowRight
+    rl.bind_sequence(
+        KeyPress::ControlLeft,
+        Cmd::Move(Movement::BackwardWord(1, Word::Vi)),
+    );
+    rl.bind_sequence(
+        KeyPress::ControlRight,
+        Cmd::Move(Movement::ForwardWord(1, At::AfterEnd, Word::Vi)),
+    );
+
+    // workaround for multiline-paste hang in rustyline (see https://github.com/kkawakam/rustyline/issues/202)
+    rl.bind_sequence(KeyPress::BracketedPasteStart, 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: &mut 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.expect_string() == "false" {
+                return None;
+            }
+        }
+    }
+
+    Some(rustyline::hint::HistoryHinter {})
+}
+
+pub fn configure_ctrl_c(_context: &mut 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/prelude.rs

@@ -0,0 +1,92 @@
+#[macro_export]
+macro_rules! return_err {
+    ($expr:expr) => {
+        match $expr {
+            Err(_) => return,
+            Ok(expr) => expr,
+        };
+    };
+}
+
+#[macro_export]
+macro_rules! stream {
+    ($($expr:expr),*) => {{
+        let mut v = VecDeque::new();
+
+        $(
+            v.push_back($expr);
+        )*
+
+        v
+    }}
+}
+
+#[macro_export]
+macro_rules! trace_out_stream {
+    (target: $target:tt, $desc:tt = $expr:expr) => {{
+        if log::log_enabled!(target: $target, log::Level::Trace) {
+            use futures::stream::StreamExt;
+
+            let objects = $expr.inspect(move |o| {
+                trace!(
+                    target: $target,
+                    "{} = {}",
+                    $desc,
+                    match o {
+                        Err(err) => format!("{:?}", err),
+                        Ok(value) => value.display(),
+                    }
+                );
+            });
+
+            nu_stream::OutputStream::new(objects)
+        } else {
+            $expr
+        }
+    }};
+}
+
+pub(crate) use futures::{Stream, StreamExt};
+pub(crate) use nu_engine::Host;
+#[allow(unused_imports)]
+pub(crate) use nu_errors::ShellError;
+#[allow(unused_imports)]
+pub(crate) use nu_protocol::outln;
+pub(crate) use nu_stream::OutputStream;
+#[allow(unused_imports)]
+pub(crate) use nu_value_ext::ValueExt;
+#[allow(unused_imports)]
+pub(crate) use std::sync::atomic::Ordering;
+
+#[allow(clippy::clippy::wrong_self_convention)]
+pub trait FromInputStream {
+    fn from_input_stream(self) -> OutputStream;
+}
+
+impl<T> FromInputStream for T
+where
+    T: Stream<Item = nu_protocol::Value> + Send + 'static,
+{
+    fn from_input_stream(self) -> OutputStream {
+        OutputStream {
+            values: self.map(nu_protocol::ReturnSuccess::value).boxed(),
+        }
+    }
+}
+
+#[allow(clippy::clippy::wrong_self_convention)]
+pub trait ToOutputStream {
+    fn to_output_stream(self) -> OutputStream;
+}
+
+impl<T, U> ToOutputStream for T
+where
+    T: Stream<Item = U> + Send + 'static,
+    U: Into<nu_protocol::ReturnValue>,
+{
+    fn to_output_stream(self) -> OutputStream {
+        OutputStream {
+            values: self.map(|item| item.into()).boxed(),
+        }
+    }
+}

crates/nu-cli/src/shell.rs

@@ -0,0 +1,9 @@
+#![allow(clippy::module_inception)]
+
+#[cfg(feature = "rustyline-support")]
+pub(crate) mod completer;
+#[cfg(feature = "rustyline-support")]
+pub(crate) mod helper;
+
+#[cfg(feature = "rustyline-support")]
+pub(crate) use helper::Helper;

crates/nu-cli/src/shell/completer.rs

@@ -0,0 +1,157 @@
+use crate::completion::command::CommandCompleter;
+use crate::completion::flag::FlagCompleter;
+use crate::completion::matchers;
+use crate::completion::matchers::Matcher;
+use crate::completion::path::{PathCompleter, PathSuggestion};
+use crate::completion::{self, Completer, Suggestion};
+use nu_engine::EvaluationContext;
+use nu_parser::ParserScope;
+use nu_source::Tag;
+
+use std::borrow::Cow;
+
+pub(crate) struct NuCompleter {}
+
+impl NuCompleter {}
+
+impl NuCompleter {
+    pub fn complete(
+        &self,
+        line: &str,
+        pos: usize,
+        context: &completion::CompletionContext,
+    ) -> (usize, Vec<Suggestion>) {
+        use completion::engine::LocationType;
+
+        let nu_context: &EvaluationContext = context.as_ref();
+
+        nu_context.scope.enter_scope();
+        let (block, _) = nu_parser::parse(line, 0, &nu_context.scope);
+        nu_context.scope.exit_scope();
+
+        let locations = completion::engine::completion_location(line, &block, pos);
+
+        let matcher = nu_data::config::config(Tag::unknown())
+            .ok()
+            .and_then(|cfg| cfg.get("line_editor").cloned())
+            .and_then(|le| {
+                le.row_entries()
+                    .find(|(idx, _value)| idx.as_str() == "completion_match_method")
+                    .and_then(|(_idx, value)| value.as_string().ok())
+            })
+            .unwrap_or_else(String::new);
+
+        let matcher = matcher.as_str();
+        let matcher: &dyn Matcher = match matcher {
+            "case-insensitive" => &matchers::case_insensitive::Matcher,
+            _ => &matchers::case_sensitive::Matcher,
+        };
+
+        if locations.is_empty() {
+            (pos, Vec::new())
+        } else {
+            let pos = locations[0].span.start();
+            let suggestions = locations
+                .into_iter()
+                .flat_map(|location| {
+                    let partial = location.span.slice(line);
+                    match location.item {
+                        LocationType::Command => {
+                            let command_completer = CommandCompleter;
+                            command_completer.complete(context, partial, matcher.to_owned())
+                        }
+
+                        LocationType::Flag(cmd) => {
+                            let flag_completer = FlagCompleter { cmd };
+                            flag_completer.complete(context, partial, matcher.to_owned())
+                        }
+
+                        LocationType::Argument(cmd, _arg_name) => {
+                            let path_completer = PathCompleter;
+
+                            const QUOTE_CHARS: &[char] = &['\'', '"', '`'];
+
+                            // TODO Find a better way to deal with quote chars. Can the completion
+                            //      engine relay this back to us? Maybe have two spans: inner and
+                            //      outer. The former is what we want to complete, the latter what
+                            //      we'd need to replace.
+                            let (quote_char, partial) = if partial.starts_with(QUOTE_CHARS) {
+                                let (head, tail) = partial.split_at(1);
+                                (Some(head), tail)
+                            } else {
+                                (None, partial)
+                            };
+
+                            let partial = if let Some(quote_char) = quote_char {
+                                if partial.ends_with(quote_char) {
+                                    &partial[..partial.len() - 1]
+                                } else {
+                                    partial
+                                }
+                            } else {
+                                partial
+                            };
+
+                            let completed_paths = path_completer.path_suggestions(partial, matcher);
+                            match cmd.as_deref().unwrap_or("") {
+                                "cd" => select_directory_suggestions(completed_paths),
+                                _ => completed_paths,
+                            }
+                            .into_iter()
+                            .map(|s| Suggestion {
+                                replacement: requote(s.suggestion.replacement),
+                                display: s.suggestion.display,
+                            })
+                            .collect()
+                        }
+
+                        LocationType::Variable => Vec::new(),
+                    }
+                })
+                .collect();
+
+            (pos, suggestions)
+        }
+    }
+}
+
+fn select_directory_suggestions(completed_paths: Vec<PathSuggestion>) -> Vec<PathSuggestion> {
+    completed_paths
+        .into_iter()
+        .filter(|suggestion| {
+            suggestion
+                .path
+                .metadata()
+                .map(|md| md.is_dir())
+                .unwrap_or(false)
+        })
+        .collect()
+}
+
+fn requote(orig_value: String) -> String {
+    let value: Cow<str> = rustyline::completion::unescape(&orig_value, Some('\\'));
+
+    let mut quotes = vec!['"', '\'', '`'];
+    let mut should_quote = false;
+    for c in value.chars() {
+        if c.is_whitespace() {
+            should_quote = true;
+        } else if let Some(index) = quotes.iter().position(|q| *q == c) {
+            should_quote = true;
+            quotes.swap_remove(index);
+        }
+    }
+
+    if should_quote {
+        if quotes.is_empty() {
+            // TODO we don't really have an escape character, so there isn't a great option right
+            //      now. One possibility is `{{$(char backtick)}}`
+            value.to_string()
+        } else {
+            let quote = quotes[0];
+            format!("{}{}{}", quote, value, quote)
+        }
+    } else {
+        value.to_string()
+    }
+}

crates/nu-cli/src/shell/helper.rs

@@ -0,0 +1,194 @@
+use crate::completion;
+use crate::shell::completer::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 {},
+        }
+    }
+}
+
+impl rustyline::completion::Candidate for completion::Suggestion {
+    fn display(&self) -> &str {
+        &self.display
+    }
+
+    fn replacement(&self) -> &str {
+        &self.replacement
+    }
+}
+
+impl rustyline::completion::Completer for Helper {
+    type Candidate = completion::Suggestion;
+
+    fn complete(
+        &self,
+        line: &str,
+        pos: usize,
+        _ctx: &rustyline::Context<'_>,
+    ) -> Result<(usize, Vec<Self::Candidate>), rustyline::error::ReadlineError> {
+        let ctx = completion::CompletionContext::new(&self.context);
+        Ok(self.completer.complete(line, pos, &ctx))
+    }
+
+    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 {
+    fn hint(&self, line: &str, pos: usize, ctx: &rustyline::Context<'_>) -> Option<String> {
+        self.hinter.as_ref().and_then(|h| h.hint(line, pos, &ctx))
+    }
+}
+
+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("\x1b[1m".to_owned() + hint + "\x1b[m")
+    }
+
+    fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
+        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);
+        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::basic_evaluation_context;
+    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(basic_evaluation_context().unwrap(), 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(basic_evaluation_context().unwrap(), None);
+
+        helper.update(&mut buffer, "cd ".len(), &replacement);
+
+        assert_eq!(
+            buffer.as_str(),
+            "cd \"folder with spaces\\subdirectory\\subsubdirectory\\\""
+        );
+    }
+}

crates/nu-cli/src/types.rs

@@ -0,0 +1 @@
+pub(crate) mod deduction;

crates/nu-command/Cargo.toml

@@ -0,0 +1,135 @@
+[package]
+authors = ["The Nu Project Contributors"]
+build = "build.rs"
+description = "CLI for nushell"
+edition = "2018"
+license = "MIT"
+name = "nu-command"
+version = "0.28.0"
+
+[lib]
+doctest = false
+
+[dependencies]
+nu-data = { version = "0.28.0", path = "../nu-data" }
+nu-engine = { version = "0.28.0", path = "../nu-engine" }
+nu-errors = { version = "0.28.0", path = "../nu-errors" }
+nu-json = { version = "0.28.0", path = "../nu-json" }
+nu-parser = { version = "0.28.0", path = "../nu-parser" }
+nu-plugin = { version = "0.28.0", path = "../nu-plugin" }
+nu-protocol = { version = "0.28.0", path = "../nu-protocol" }
+nu-source = { version = "0.28.0", path = "../nu-source" }
+nu-stream = { version = "0.28.0", path = "../nu-stream" }
+nu-table = { version = "0.28.0", path = "../nu-table" }
+nu-test-support = { version = "0.28.0", path = "../nu-test-support" }
+nu-value-ext = { version = "0.28.0", path = "../nu-value-ext" }
+nu-ansi-term = { version = "0.28.0", path = "../nu-ansi-term" }
+
+Inflector = "0.11"
+arboard = { version = "1.1.0", optional = true }
+async-recursion = "0.3.2"
+async-trait = "0.1.42"
+base64 = "0.13.0"
+bigdecimal = { version = "0.2.0", features = ["serde"] }
+byte-unit = "4.0.9"
+bytes = "1.0.1"
+calamine = "0.17.0"
+chrono = { version = "0.4.19", features = ["serde"] }
+chrono-tz = "0.5.3"
+clap = "2.33.3"
+codespan-reporting = "0.11.0"
+crossterm = { version = "0.19.0", optional = true }
+csv = "1.1.3"
+ctrlc = { version = "3.1.7", optional = true }
+derive-new = "0.5.8"
+directories-next = { version = "2.0.0", optional = true }
+dirs-next = { version = "2.0.0", optional = true }
+dtparse = "1.2.0"
+dunce = "1.0.1"
+eml-parser = "0.1.0"
+encoding_rs = "0.8.28"
+filesize = "0.2.0"
+fs_extra = "1.2.0"
+futures = { version = "0.3.12", features = ["compat", "io-compat"] }
+futures-util = "0.3.12"
+futures_codec = "0.4.1"
+getset = "0.1.1"
+glob = "0.3.0"
+htmlescape = "0.3.1"
+ical = "0.7.0"
+ichwh = { version = "0.3.4", optional = true }
+indexmap = { version = "1.6.1", features = ["serde-1"] }
+itertools = "0.10.0"
+lazy_static = "1.*"
+log = "0.4.14"
+meval = "0.2.0"
+minus = { version = "3.3.0", optional = true, features = ["async_std_lib", "search"] }
+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"
+pin-utils = "0.1.0"
+pretty-hex = "0.2.1"
+ptree = { version = "0.3.1", optional = true }
+query_interface = "0.3.5"
+quick-xml = "0.21.0"
+rand = "0.7.3"
+rayon = "1.5.0"
+regex = "1.4.3"
+roxmltree = "0.14.0"
+rust-embed = "5.9.0"
+rustyline = { version = "7.1.0", optional = true }
+serde = { version = "1.0.123", features = ["derive"] }
+serde_bytes = "0.11.5"
+serde_ini = "0.2.0"
+serde_json = "1.0.61"
+serde_urlencoded = "0.7.0"
+serde_yaml = "0.8.16"
+sha2 = "0.9.3"
+shellexpand = "2.1.0"
+strip-ansi-escapes = "0.1.0"
+sxd-document = "0.3.2"
+sxd-xpath = "0.4.2"
+tempfile = "3.2.0"
+term = { version = "0.7.0", optional = true }
+term_size = "0.3.2"
+termcolor = "1.1.2"
+titlecase = "1.1.0"
+toml = "0.5.8"
+trash = { version = "1.3.0", optional = true }
+unicode-segmentation = "1.7.1"
+url = "2.2.0"
+uuid_crate = { package = "uuid", version = "0.8.2", features = ["v4"], optional = true }
+which = { version = "4.0.2", optional = true }
+zip = { version = "0.5.9", optional = true }
+
+[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"]}
+
+[dependencies.rusqlite]
+features = ["bundled", "blob"]
+optional = true
+version = "0.24.2"
+
+[build-dependencies]
+shadow-rs = "0.5"
+
+[dev-dependencies]
+quickcheck = "1.0.3"
+quickcheck_macros = "1.0.0"
+
+[features]
+clipboard-cli = ["arboard"]
+rustyline-support = ["rustyline"]
+stable = []
+trash-support = ["trash"]
+directories = ["directories-next"]
+dirs = ["dirs-next"]
+table-pager = ["minus", "crossterm"]

crates/nu-command/build.rs

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

crates/nu-command/src/commands.rs

@@ -0,0 +1,366 @@
+#[macro_use]
+pub(crate) mod macros;
+
+mod from_delimited_data;
+mod to_delimited_data;
+
+pub(crate) mod ansi;
+pub(crate) mod append;
+pub(crate) mod args;
+pub mod autoenv;
+pub(crate) mod autoenv_trust;
+pub(crate) mod autoenv_untrust;
+pub(crate) mod autoview;
+pub(crate) mod benchmark;
+pub(crate) mod build_string;
+pub(crate) mod cal;
+pub(crate) mod cd;
+pub(crate) mod char_;
+pub(crate) mod chart;
+pub(crate) mod classified;
+#[cfg(feature = "clipboard-cli")]
+pub(crate) mod clip;
+pub mod command;
+pub(crate) mod compact;
+pub(crate) mod config;
+pub(crate) mod constants;
+pub(crate) mod count;
+pub(crate) mod cp;
+pub(crate) mod date;
+pub(crate) mod debug;
+pub(crate) mod def;
+pub(crate) mod default;
+pub mod default_context;
+pub(crate) mod describe;
+pub(crate) mod do_;
+pub(crate) mod drop;
+pub(crate) mod du;
+pub(crate) mod each;
+pub(crate) mod echo;
+pub(crate) mod empty;
+pub(crate) mod enter;
+pub(crate) mod every;
+pub(crate) mod exec;
+pub(crate) mod exit;
+pub(crate) mod first;
+pub(crate) mod flatten;
+pub(crate) mod format;
+pub(crate) mod from;
+pub(crate) mod from_csv;
+pub(crate) mod from_eml;
+pub(crate) mod from_ics;
+pub(crate) mod from_ini;
+pub(crate) mod from_json;
+pub(crate) mod from_ods;
+pub(crate) mod from_ssv;
+pub(crate) mod from_toml;
+pub(crate) mod from_tsv;
+pub(crate) mod from_url;
+pub(crate) mod from_vcf;
+pub(crate) mod from_xlsx;
+pub(crate) mod from_xml;
+pub(crate) mod from_yaml;
+pub(crate) mod get;
+pub(crate) mod group_by;
+pub(crate) mod group_by_date;
+pub(crate) mod hash_;
+pub(crate) mod headers;
+pub(crate) mod help;
+pub(crate) mod histogram;
+pub(crate) mod history;
+pub(crate) mod if_;
+pub(crate) mod insert;
+pub(crate) mod into_int;
+pub(crate) mod keep;
+pub(crate) mod last;
+pub(crate) mod let_;
+pub(crate) mod let_env;
+pub(crate) mod lines;
+pub(crate) mod ls;
+pub(crate) mod math;
+pub(crate) mod merge;
+pub(crate) mod mkdir;
+pub(crate) mod move_;
+pub(crate) mod next;
+pub(crate) mod nth;
+pub(crate) mod nu;
+pub(crate) mod open;
+pub(crate) mod parse;
+pub(crate) mod path;
+pub(crate) mod pivot;
+pub(crate) mod prepend;
+pub(crate) mod prev;
+pub(crate) mod pwd;
+pub(crate) mod random;
+pub(crate) mod range;
+pub(crate) mod reduce;
+pub(crate) mod reject;
+pub(crate) mod rename;
+pub(crate) mod reverse;
+pub(crate) mod rm;
+pub(crate) mod roll;
+pub(crate) mod rotate;
+pub(crate) mod run_external;
+pub(crate) mod save;
+pub(crate) mod select;
+pub(crate) mod seq;
+pub(crate) mod seq_dates;
+pub(crate) mod shells;
+pub(crate) mod shuffle;
+pub(crate) mod size;
+pub(crate) mod skip;
+pub(crate) mod sleep;
+pub(crate) mod sort_by;
+pub(crate) mod source;
+pub(crate) mod split;
+pub(crate) mod split_by;
+pub(crate) mod str_;
+pub(crate) mod table;
+pub(crate) mod tags;
+pub(crate) mod termsize;
+pub(crate) mod to;
+pub(crate) mod to_csv;
+pub(crate) mod to_html;
+pub(crate) mod to_json;
+pub(crate) mod to_md;
+pub(crate) mod to_toml;
+pub(crate) mod to_tsv;
+pub(crate) mod to_url;
+pub(crate) mod to_xml;
+pub(crate) mod to_yaml;
+pub(crate) mod uniq;
+pub(crate) mod update;
+pub(crate) mod url_;
+pub(crate) mod version;
+pub(crate) mod where_;
+pub(crate) mod which_;
+pub(crate) mod with_env;
+pub(crate) mod wrap;
+
+pub(crate) use autoview::Autoview;
+pub(crate) use cd::Cd;
+
+pub(crate) use ansi::Ansi;
+pub(crate) use ansi::AnsiStrip;
+pub(crate) use append::Command as Append;
+pub(crate) use autoenv::Autoenv;
+pub(crate) use autoenv_trust::AutoenvTrust;
+pub(crate) use autoenv_untrust::AutoenvUnTrust;
+pub(crate) use benchmark::Benchmark;
+pub(crate) use build_string::BuildString;
+pub(crate) use cal::Cal;
+pub(crate) use char_::Char;
+pub(crate) use chart::Chart;
+pub(crate) use compact::Compact;
+pub(crate) use config::{
+    Config, ConfigClear, ConfigGet, ConfigLoad, ConfigPath, ConfigRemove, ConfigSet, ConfigSetInto,
+};
+pub(crate) use count::Count;
+pub(crate) use cp::Cpy;
+pub(crate) use date::{Date, DateFormat, DateListTimeZone, DateNow, DateToTable, DateToTimeZone};
+pub(crate) use debug::Debug;
+pub(crate) use def::Def;
+pub(crate) use default::Default;
+pub(crate) use describe::Describe;
+pub(crate) use do_::Do;
+pub(crate) use drop::{Drop, DropColumn};
+pub(crate) use du::Du;
+pub(crate) use each::Each;
+pub(crate) use each::EachGroup;
+pub(crate) use each::EachWindow;
+pub(crate) use echo::Echo;
+pub(crate) use empty::Command as Empty;
+pub(crate) use if_::If;
+pub(crate) use nu::NuPlugin;
+pub(crate) use update::Command as Update;
+pub(crate) mod kill;
+pub(crate) use kill::Kill;
+pub(crate) mod clear;
+pub(crate) use clear::Clear;
+pub(crate) mod touch;
+pub(crate) use enter::Enter;
+pub(crate) use every::Every;
+pub(crate) use exec::Exec;
+pub(crate) use exit::Exit;
+pub(crate) use first::First;
+pub(crate) use flatten::Command as Flatten;
+pub(crate) use format::{FileSize, Format};
+pub(crate) use from::From;
+pub(crate) use from_csv::FromCSV;
+pub(crate) use from_eml::FromEML;
+pub(crate) use from_ics::FromIcs;
+pub(crate) use from_ini::FromINI;
+pub(crate) use from_json::FromJSON;
+pub(crate) use from_ods::FromODS;
+pub(crate) use from_ssv::FromSSV;
+pub(crate) use from_toml::FromTOML;
+pub(crate) use from_tsv::FromTSV;
+pub(crate) use from_url::FromURL;
+pub(crate) use from_vcf::FromVcf;
+pub(crate) use from_xlsx::FromXLSX;
+pub(crate) use from_xml::FromXML;
+pub(crate) use from_yaml::FromYAML;
+pub(crate) use from_yaml::FromYML;
+pub(crate) use get::Command as Get;
+pub(crate) use group_by::Command as GroupBy;
+pub(crate) use group_by_date::GroupByDate;
+pub(crate) use hash_::{Hash, HashBase64};
+pub(crate) use headers::Headers;
+pub(crate) use help::Help;
+pub(crate) use histogram::Histogram;
+pub(crate) use history::History;
+pub(crate) use insert::Command as Insert;
+pub(crate) use into_int::IntoInt;
+pub(crate) use keep::{Keep, KeepUntil, KeepWhile};
+pub(crate) use last::Last;
+pub(crate) use let_::Let;
+pub(crate) use let_env::LetEnv;
+pub(crate) use lines::Lines;
+pub(crate) use ls::Ls;
+pub(crate) use math::{
+    Math, MathAbs, MathAverage, MathCeil, MathEval, MathFloor, MathMaximum, MathMedian,
+    MathMinimum, MathMode, MathProduct, MathRound, MathStddev, MathSummation, MathVariance,
+};
+pub(crate) use merge::Merge;
+pub(crate) use mkdir::Mkdir;
+pub(crate) use move_::{Move, Mv};
+pub(crate) use next::Next;
+pub(crate) use nth::Nth;
+pub(crate) use open::Open;
+pub(crate) use parse::Parse;
+pub(crate) use path::{
+    PathBasename, PathCommand, PathDirname, PathExists, PathExpand, PathExtension, PathFilestem,
+    PathJoin, PathType,
+};
+pub(crate) use pivot::Pivot;
+pub(crate) use prepend::Prepend;
+pub(crate) use prev::Previous;
+pub(crate) use pwd::Pwd;
+#[cfg(feature = "uuid_crate")]
+pub(crate) use random::RandomUUID;
+pub(crate) use random::{
+    Random, RandomBool, RandomChars, RandomDecimal, RandomDice, RandomInteger,
+};
+pub(crate) use range::Range;
+pub(crate) use reduce::Reduce;
+pub(crate) use reject::Reject;
+pub(crate) use rename::Rename;
+pub(crate) use reverse::Reverse;
+pub(crate) use rm::Remove;
+pub(crate) use roll::{Roll, RollColumn, RollUp};
+pub(crate) use rotate::{Rotate, RotateCounterClockwise};
+pub(crate) use run_external::RunExternalCommand;
+pub(crate) use save::Save;
+pub(crate) use select::Command as Select;
+pub(crate) use seq::Seq;
+pub(crate) use seq_dates::SeqDates;
+pub(crate) use shells::Shells;
+pub(crate) use shuffle::Shuffle;
+pub(crate) use size::Size;
+pub(crate) use skip::{Skip, SkipUntil, SkipWhile};
+pub(crate) use sleep::Sleep;
+pub(crate) use sort_by::SortBy;
+pub(crate) use source::Source;
+pub(crate) use split::{Split, SplitChars, SplitColumn, SplitRow};
+pub(crate) use split_by::SplitBy;
+pub(crate) use str_::{
+    Str, StrCamelCase, StrCapitalize, StrCollect, StrContains, StrDowncase, StrEndsWith,
+    StrFindReplace, StrFrom, StrIndexOf, StrKebabCase, StrLPad, StrLength, StrPascalCase, StrRPad,
+    StrReverse, StrScreamingSnakeCase, StrSnakeCase, StrStartsWith, StrSubstring, StrToDatetime,
+    StrToDecimal, StrToInteger, StrTrim, StrTrimLeft, StrTrimRight, StrUpcase,
+};
+pub(crate) use table::Table;
+pub(crate) use tags::Tags;
+pub(crate) use termsize::TermSize;
+pub(crate) use to::To;
+pub(crate) use to_csv::ToCSV;
+pub(crate) use to_html::ToHTML;
+pub(crate) use to_json::ToJSON;
+pub(crate) use to_md::Command as ToMarkdown;
+pub(crate) use to_toml::ToTOML;
+pub(crate) use to_tsv::ToTSV;
+pub(crate) use to_url::ToURL;
+pub(crate) use to_xml::ToXML;
+pub(crate) use to_yaml::ToYAML;
+pub(crate) use touch::Touch;
+pub(crate) use uniq::Uniq;
+pub(crate) use url_::{UrlCommand, UrlHost, UrlPath, UrlQuery, UrlScheme};
+pub(crate) use version::Version;
+pub(crate) use where_::Where;
+pub(crate) use which_::Which;
+pub(crate) use with_env::WithEnv;
+pub(crate) use wrap::Wrap;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::examples::{test_anchors, test_examples};
+    use nu_engine::{whole_stream_command, Command};
+    use nu_errors::ShellError;
+
+    fn full_tests() -> Vec<Command> {
+        vec![
+            whole_stream_command(Append),
+            whole_stream_command(GroupBy),
+            whole_stream_command(Insert),
+            whole_stream_command(Move),
+            whole_stream_command(Update),
+            whole_stream_command(Empty),
+            // whole_stream_command(Select),
+            // whole_stream_command(Get),
+            // Str Command Suite
+            whole_stream_command(Str),
+            whole_stream_command(StrToDecimal),
+            whole_stream_command(StrToInteger),
+            whole_stream_command(StrDowncase),
+            whole_stream_command(StrUpcase),
+            whole_stream_command(StrCapitalize),
+            whole_stream_command(StrFindReplace),
+            whole_stream_command(StrFrom),
+            whole_stream_command(StrSubstring),
+            whole_stream_command(StrToDatetime),
+            whole_stream_command(StrContains),
+            whole_stream_command(StrIndexOf),
+            whole_stream_command(StrTrim),
+            whole_stream_command(StrTrimLeft),
+            whole_stream_command(StrTrimRight),
+            whole_stream_command(StrStartsWith),
+            whole_stream_command(StrEndsWith),
+            //whole_stream_command(StrCollect),
+            whole_stream_command(StrLength),
+            whole_stream_command(StrLPad),
+            whole_stream_command(StrReverse),
+            whole_stream_command(StrRPad),
+            whole_stream_command(StrCamelCase),
+            whole_stream_command(StrPascalCase),
+            whole_stream_command(StrKebabCase),
+            whole_stream_command(StrSnakeCase),
+            whole_stream_command(StrScreamingSnakeCase),
+            whole_stream_command(ToMarkdown),
+        ]
+    }
+
+    fn only_examples() -> Vec<Command> {
+        let mut commands = full_tests();
+        commands.extend(vec![whole_stream_command(Flatten)]);
+        commands
+    }
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        for cmd in only_examples() {
+            test_examples(cmd)?;
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn tracks_metadata() -> Result<(), ShellError> {
+        for cmd in full_tests() {
+            test_anchors(cmd)?;
+        }
+
+        Ok(())
+    }
+}

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

@@ -0,0 +1,359 @@
+use crate::prelude::*;
+use nu_ansi_term::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct Command;
+
+#[derive(Deserialize)]
+struct AnsiArgs {
+    code: Value,
+    escape: Option<Tagged<String>>,
+    osc: Option<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "ansi"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("ansi")
+            .optional(
+                "code",
+                SyntaxShape::Any,
+                "the name of the code to use like 'green' or 'reset' to reset the color",
+            )
+            .named(
+                "escape", // \x1b[
+                SyntaxShape::Any,
+                "escape sequence without the escape character(s)",
+                Some('e'),
+            )
+            .named(
+                "osc", // \x1b]
+                SyntaxShape::Any,
+                "operating system command (ocs) escape sequence without the escape character(s)",
+                Some('o'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Output ANSI codes to change color."
+    }
+
+    fn extra_usage(&self) -> &str {
+        r#"For escape sequences:
+Escape: '\x1b[' is not required for --escape parameter
+Format: #(;#)m
+Example: 1;31m for bold red or 2;37;41m for dimmed white fg with red bg
+There can be multiple text formatting sequence numbers
+separated by a ; and ending with an m where the # is of the
+following values:
+    attributes
+    0    reset / normal display
+    1    bold or increased intensity
+    2    faint or decreased intensity
+    3    italic on (non-mono font)
+    4    underline on
+    5    slow blink on
+    6    fast blink on
+    7    reverse video on
+    8    nondisplayed (invisible) on
+    9    strike-through on
+
+    foreground/bright colors    background/bright colors
+    30/90    black              40/100    black
+    31/91    red                41/101    red
+    32/92    green              42/102    green
+    33/93    yellow             43/103    yellow
+    34/94    blue               44/104    blue
+    35/95    magenta            45/105    magenta
+    36/96    cyan               46/106    cyan
+    37/97    white              47/107    white
+    https://en.wikipedia.org/wiki/ANSI_escape_code
+
+OSC: '\x1b]' is not required for --osc parameter
+Example: echo [$(ansi -o '0') 'some title' $(char bel)] | str collect
+Format: #
+    0 Set window title and icon name
+    1 Set icon name
+    2 Set window title
+    4 Set/read color palette
+    9 iTerm2 Grown notifications
+    10 Set foreground color (x11 color spec)
+    11 Set background color (x11 color spec)
+    ... others"#
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Change color to green",
+                example: r#"ansi green"#,
+                result: Some(vec![Value::from("\u{1b}[32m")]),
+            },
+            Example {
+                description: "Reset the color",
+                example: r#"ansi reset"#,
+                result: Some(vec![Value::from("\u{1b}[0m")]),
+            },
+            Example {
+                description:
+                    "Use ansi to color text (rb = red bold, gb = green bold, pb = purple bold)",
+                example: r#"echo [$(ansi rb) Hello " " $(ansi gb) Nu " " $(ansi pb) World] | str collect"#,
+                result: Some(vec![Value::from(
+                    "\u{1b}[1;31mHello \u{1b}[1;32mNu \u{1b}[1;35mWorld",
+                )]),
+            },
+            Example {
+                description:
+                    "Use ansi to color text (rb = red bold, gb = green bold, pb = purple bold)",
+                example: r#"echo [$(ansi -e '3;93;41m') Hello $(ansi reset) " " $(ansi gb) Nu " " $(ansi pb) World] | str collect"#,
+                result: Some(vec![Value::from(
+                    "\u{1b}[3;93;41mHello\u{1b}[0m \u{1b}[1;32mNu \u{1b}[1;35mWorld",
+                )]),
+            },
+        ]
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let (AnsiArgs { code, escape, osc }, _) = args.process().await?;
+
+        if let Some(e) = escape {
+            let esc_vec: Vec<char> = e.item.chars().collect();
+            if esc_vec[0] == '\\' {
+                return Err(ShellError::labeled_error(
+                    "no need for escape characters",
+                    "no need for escape characters",
+                    e.tag(),
+                ));
+            }
+            let output = format!("\x1b[{}", e.item);
+            return Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(e.tag()),
+            )));
+        }
+
+        if let Some(o) = osc {
+            let osc_vec: Vec<char> = o.item.chars().collect();
+            if osc_vec[0] == '\\' {
+                return Err(ShellError::labeled_error(
+                    "no need for escape characters",
+                    "no need for escape characters",
+                    o.tag(),
+                ));
+            }
+
+            //Operating system command aka osc  ESC ] <- note the right brace, not left brace for osc
+            // OCS's need to end with a bell '\x07' char
+            let output = format!("\x1b]{};", o.item);
+            return Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(o.tag()),
+            )));
+        }
+
+        let code_string = code.as_string()?;
+        let ansi_code = str_to_ansi(code_string);
+
+        if let Some(output) = ansi_code {
+            Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(code.tag()),
+            )))
+        } else {
+            Err(ShellError::labeled_error(
+                "Unknown ansi code",
+                "unknown ansi code",
+                code.tag(),
+            ))
+        }
+    }
+}
+
+pub fn str_to_ansi(s: String) -> Option<String> {
+    match s.as_str() {
+        "g" | "green" => Some(Color::Green.prefix().to_string()),
+        "gb" | "green_bold" => Some(Color::Green.bold().prefix().to_string()),
+        "gu" | "green_underline" => Some(Color::Green.underline().prefix().to_string()),
+        "gi" | "green_italic" => Some(Color::Green.italic().prefix().to_string()),
+        "gd" | "green_dimmed" => Some(Color::Green.dimmed().prefix().to_string()),
+        "gr" | "green_reverse" => Some(Color::Green.reverse().prefix().to_string()),
+
+        "lg" | "light_green" => Some(Color::LightGreen.prefix().to_string()),
+        "lgb" | "light_green_bold" => Some(Color::LightGreen.bold().prefix().to_string()),
+        "lgu" | "light_green_underline" => Some(Color::LightGreen.underline().prefix().to_string()),
+        "lgi" | "light_green_italic" => Some(Color::LightGreen.italic().prefix().to_string()),
+        "lgd" | "light_green_dimmed" => Some(Color::LightGreen.dimmed().prefix().to_string()),
+        "lgr" | "light_green_reverse" => Some(Color::LightGreen.reverse().prefix().to_string()),
+
+        "r" | "red" => Some(Color::Red.prefix().to_string()),
+        "rb" | "red_bold" => Some(Color::Red.bold().prefix().to_string()),
+        "ru" | "red_underline" => Some(Color::Red.underline().prefix().to_string()),
+        "ri" | "red_italic" => Some(Color::Red.italic().prefix().to_string()),
+        "rd" | "red_dimmed" => Some(Color::Red.dimmed().prefix().to_string()),
+        "rr" | "red_reverse" => Some(Color::Red.reverse().prefix().to_string()),
+
+        "lr" | "light_red" => Some(Color::LightRed.prefix().to_string()),
+        "lrb" | "light_red_bold" => Some(Color::LightRed.bold().prefix().to_string()),
+        "lru" | "light_red_underline" => Some(Color::LightRed.underline().prefix().to_string()),
+        "lri" | "light_red_italic" => Some(Color::LightRed.italic().prefix().to_string()),
+        "lrd" | "light_red_dimmed" => Some(Color::LightRed.dimmed().prefix().to_string()),
+        "lrr" | "light_red_reverse" => Some(Color::LightRed.reverse().prefix().to_string()),
+
+        "u" | "blue" => Some(Color::Blue.prefix().to_string()),
+        "ub" | "blue_bold" => Some(Color::Blue.bold().prefix().to_string()),
+        "uu" | "blue_underline" => Some(Color::Blue.underline().prefix().to_string()),
+        "ui" | "blue_italic" => Some(Color::Blue.italic().prefix().to_string()),
+        "ud" | "blue_dimmed" => Some(Color::Blue.dimmed().prefix().to_string()),
+        "ur" | "blue_reverse" => Some(Color::Blue.reverse().prefix().to_string()),
+
+        "lu" | "light_blue" => Some(Color::LightBlue.prefix().to_string()),
+        "lub" | "light_blue_bold" => Some(Color::LightBlue.bold().prefix().to_string()),
+        "luu" | "light_blue_underline" => Some(Color::LightBlue.underline().prefix().to_string()),
+        "lui" | "light_blue_italic" => Some(Color::LightBlue.italic().prefix().to_string()),
+        "lud" | "light_blue_dimmed" => Some(Color::LightBlue.dimmed().prefix().to_string()),
+        "lur" | "light_blue_reverse" => Some(Color::LightBlue.reverse().prefix().to_string()),
+
+        "b" | "black" => Some(Color::Black.prefix().to_string()),
+        "bb" | "black_bold" => Some(Color::Black.bold().prefix().to_string()),
+        "bu" | "black_underline" => Some(Color::Black.underline().prefix().to_string()),
+        "bi" | "black_italic" => Some(Color::Black.italic().prefix().to_string()),
+        "bd" | "black_dimmed" => Some(Color::Black.dimmed().prefix().to_string()),
+        "br" | "black_reverse" => Some(Color::Black.reverse().prefix().to_string()),
+
+        "ligr" | "light_gray" => Some(Color::LightGray.prefix().to_string()),
+        "ligrb" | "light_gray_bold" => Some(Color::LightGray.bold().prefix().to_string()),
+        "ligru" | "light_gray_underline" => Some(Color::LightGray.underline().prefix().to_string()),
+        "ligri" | "light_gray_italic" => Some(Color::LightGray.italic().prefix().to_string()),
+        "ligrd" | "light_gray_dimmed" => Some(Color::LightGray.dimmed().prefix().to_string()),
+        "ligrr" | "light_gray_reverse" => Some(Color::LightGray.reverse().prefix().to_string()),
+
+        "y" | "yellow" => Some(Color::Yellow.prefix().to_string()),
+        "yb" | "yellow_bold" => Some(Color::Yellow.bold().prefix().to_string()),
+        "yu" | "yellow_underline" => Some(Color::Yellow.underline().prefix().to_string()),
+        "yi" | "yellow_italic" => Some(Color::Yellow.italic().prefix().to_string()),
+        "yd" | "yellow_dimmed" => Some(Color::Yellow.dimmed().prefix().to_string()),
+        "yr" | "yellow_reverse" => Some(Color::Yellow.reverse().prefix().to_string()),
+
+        "ly" | "light_yellow" => Some(Color::LightYellow.prefix().to_string()),
+        "lyb" | "light_yellow_bold" => Some(Color::LightYellow.bold().prefix().to_string()),
+        "lyu" | "light_yellow_underline" => {
+            Some(Color::LightYellow.underline().prefix().to_string())
+        }
+        "lyi" | "light_yellow_italic" => Some(Color::LightYellow.italic().prefix().to_string()),
+        "lyd" | "light_yellow_dimmed" => Some(Color::LightYellow.dimmed().prefix().to_string()),
+        "lyr" | "light_yellow_reverse" => Some(Color::LightYellow.reverse().prefix().to_string()),
+
+        "p" | "purple" => Some(Color::Purple.prefix().to_string()),
+        "pb" | "purple_bold" => Some(Color::Purple.bold().prefix().to_string()),
+        "pu" | "purple_underline" => Some(Color::Purple.underline().prefix().to_string()),
+        "pi" | "purple_italic" => Some(Color::Purple.italic().prefix().to_string()),
+        "pd" | "purple_dimmed" => Some(Color::Purple.dimmed().prefix().to_string()),
+        "pr" | "purple_reverse" => Some(Color::Purple.reverse().prefix().to_string()),
+
+        "lp" | "light_purple" => Some(Color::LightPurple.prefix().to_string()),
+        "lpb" | "light_purple_bold" => Some(Color::LightPurple.bold().prefix().to_string()),
+        "lpu" | "light_purple_underline" => {
+            Some(Color::LightPurple.underline().prefix().to_string())
+        }
+        "lpi" | "light_purple_italic" => Some(Color::LightPurple.italic().prefix().to_string()),
+        "lpd" | "light_purple_dimmed" => Some(Color::LightPurple.dimmed().prefix().to_string()),
+        "lpr" | "light_purple_reverse" => Some(Color::LightPurple.reverse().prefix().to_string()),
+
+        "c" | "cyan" => Some(Color::Cyan.prefix().to_string()),
+        "cb" | "cyan_bold" => Some(Color::Cyan.bold().prefix().to_string()),
+        "cu" | "cyan_underline" => Some(Color::Cyan.underline().prefix().to_string()),
+        "ci" | "cyan_italic" => Some(Color::Cyan.italic().prefix().to_string()),
+        "cd" | "cyan_dimmed" => Some(Color::Cyan.dimmed().prefix().to_string()),
+        "cr" | "cyan_reverse" => Some(Color::Cyan.reverse().prefix().to_string()),
+
+        "lc" | "light_cyan" => Some(Color::LightCyan.prefix().to_string()),
+        "lcb" | "light_cyan_bold" => Some(Color::LightCyan.bold().prefix().to_string()),
+        "lcu" | "light_cyan_underline" => Some(Color::LightCyan.underline().prefix().to_string()),
+        "lci" | "light_cyan_italic" => Some(Color::LightCyan.italic().prefix().to_string()),
+        "lcd" | "light_cyan_dimmed" => Some(Color::LightCyan.dimmed().prefix().to_string()),
+        "lcr" | "light_cyan_reverse" => Some(Color::LightCyan.reverse().prefix().to_string()),
+
+        "w" | "white" => Some(Color::White.prefix().to_string()),
+        "wb" | "white_bold" => Some(Color::White.bold().prefix().to_string()),
+        "wu" | "white_underline" => Some(Color::White.underline().prefix().to_string()),
+        "wi" | "white_italic" => Some(Color::White.italic().prefix().to_string()),
+        "wd" | "white_dimmed" => Some(Color::White.dimmed().prefix().to_string()),
+        "wr" | "white_reverse" => Some(Color::White.reverse().prefix().to_string()),
+
+        "dgr" | "dark_gray" => Some(Color::DarkGray.prefix().to_string()),
+        "dgrb" | "dark_gray_bold" => Some(Color::DarkGray.bold().prefix().to_string()),
+        "dgru" | "dark_gray_underline" => Some(Color::DarkGray.underline().prefix().to_string()),
+        "dgri" | "dark_gray_italic" => Some(Color::DarkGray.italic().prefix().to_string()),
+        "dgrd" | "dark_gray_dimmed" => Some(Color::DarkGray.dimmed().prefix().to_string()),
+        "dgrr" | "dark_gray_reverse" => Some(Color::DarkGray.reverse().prefix().to_string()),
+
+        "reset" => Some("\x1b[0m".to_owned()),
+
+        // Reference for ansi codes https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797
+        // Another good reference http://ascii-table.com/ansi-escape-sequences.php
+
+        // For setting title like `echo [$(char title) $(pwd) $(char bel)] | str collect`
+        "title" => Some("\x1b]2;".to_string()), // ESC]2; xterm sets window title using OSC syntax escapes
+
+        // Ansi Erase Sequences
+        "clear_screen" => Some("\x1b[J".to_string()), // clears the screen
+        "clear_screen_from_cursor_to_end" => Some("\x1b[0J".to_string()), // clears from cursor until end of screen
+        "clear_screen_from_cursor_to_beginning" => Some("\x1b[1J".to_string()), // clears from cursor to beginning of screen
+        "cls" | "clear_entire_screen" => Some("\x1b[2J".to_string()), // clears the entire screen
+        "erase_line" => Some("\x1b[K".to_string()),                   // clears the current line
+        "erase_line_from_cursor_to_end" => Some("\x1b[0K".to_string()), // clears from cursor to end of line
+        "erase_line_from_cursor_to_beginning" => Some("\x1b[1K".to_string()), // clears from cursor to start of line
+        "erase_entire_line" => Some("\x1b[2K".to_string()),                   // clears entire line
+
+        // Turn on/off cursor
+        "cursor_off" => Some("\x1b[?25l".to_string()),
+        "cursor_on" => Some("\x1b[?25h".to_string()),
+
+        // Turn on/off blinking
+        "cursor_blink_off" => Some("\x1b[?12l".to_string()),
+        "cursor_blink_on" => Some("\x1b[?12h".to_string()),
+
+        // Cursor position in ESC [ <r>;<c>R where r = row and c = column
+        "cursor_position" => Some("\x1b[6n".to_string()),
+
+        // Report Terminal Identity
+        "identity" => Some("\x1b[0c".to_string()),
+
+        // Ansi escape only - CSI command
+        "csi" | "escape" | "escape_left" => Some("\x1b[".to_string()),
+        // OSC escape (Operating system command)
+        "osc" | "escape_right" => Some("\x1b]".to_string()),
+
+        // Ansi RGB - Needs to be 32;2;r;g;b or 48;2;r;g;b
+        // assuming the rgb will be passed via command and no here
+        "rgb_fg" => Some("\x1b[32;2;".to_string()),
+        "rgb_bg" => Some("\x1b[48;2;".to_string()),
+
+        // Ansi color index - Needs 38;5;idx or 48;5;idx where idx = 0 to 255
+        "idx_fg" | "color_idx_fg" => Some("\x1b[38;5;".to_string()),
+        "idx_bg" | "color_idx_bg" => Some("\x1b[48;5;".to_string()),
+
+        // Returns terminal size like "[<r>;<c>R" where r is rows and c is columns
+        // This should work assuming your terminal is not greater than 999x999
+        "size" => Some("\x1b[s\x1b[999;999H\x1b[6n\x1b[u".to_string()),
+
+        _ => None,
+    }
+}
+
+#[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/ansi/mod.rs

@@ -0,0 +1,5 @@
+mod command;
+mod strip;
+
+pub use command::Command as Ansi;
+pub use strip::SubCommand as AnsiStrip;

crates/nu-command/src/commands/ansi/strip.rs

@@ -0,0 +1,121 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::ShellTypeName;
+use nu_protocol::{
+    ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::Tag;
+use strip_ansi_escapes::strip;
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+struct Arguments {
+    rest: Vec<ColumnPath>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "ansi strip"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("ansi strip").rest(
+            SyntaxShape::ColumnPath,
+            "optionally, remove ansi sequences by column paths",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "strip ansi escape sequences from string"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        operate(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "strip ansi escape sequences from string",
+            example: "echo [$(ansi gb) 'hello' $(ansi reset)] | str collect | ansi strip",
+            result: None,
+        }]
+    }
+}
+
+async fn operate(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (Arguments { rest }, input) = args.process().await?;
+    let column_paths: Vec<_> = rest;
+
+    Ok(input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                ReturnSuccess::value(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())),
+                    )?;
+                }
+
+                ReturnSuccess::value(ret)
+            }
+        })
+        .to_output_stream())
+}
+
+fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    match &input.value {
+        UntaggedValue::Primitive(Primitive::String(astring)) => {
+            let stripped_string = {
+                if let Ok(bytes) = strip(&astring) {
+                    String::from_utf8_lossy(&bytes).to_string()
+                } else {
+                    astring.to_string()
+                }
+            };
+
+            Ok(UntaggedValue::string(stripped_string).into_value(tag))
+        }
+        other => {
+            let got = format!("got {}", other.type_name());
+
+            Err(ShellError::labeled_error(
+                "value is not string",
+                got,
+                tag.into().span,
+            ))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::{action, SubCommand};
+    use nu_protocol::UntaggedValue;
+    use nu_source::Tag;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(SubCommand {})
+    }
+
+    #[test]
+    fn test_stripping() {
+        let input_string =
+            UntaggedValue::string("\u{1b}[3;93;41mHello\u{1b}[0m \u{1b}[1;32mNu \u{1b}[1;35mWorld")
+                .into_untagged_value();
+        let expected = UntaggedValue::string("Hello Nu World").into_untagged_value();
+
+        let actual = action(&input_string, Tag::unknown()).unwrap();
+        assert_eq!(actual, expected);
+    }
+}

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

@@ -0,0 +1,85 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+#[derive(Deserialize)]
+struct Arguments {
+    value: Value,
+}
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "append"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("append").required(
+            "row value",
+            SyntaxShape::Any,
+            "the value of the row to append to the table",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Append a row to the table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let (Arguments { mut value }, input) = args.process().await?;
+
+        let input: Vec<Value> = input.collect().await;
+
+        if let Some(first) = input.get(0) {
+            value.tag = first.tag();
+        }
+
+        // Checks if we are trying to append a row literal
+        if let Value {
+            value: UntaggedValue::Table(values),
+            tag,
+        } = &value
+        {
+            if values.len() == 1 && values[0].is_row() {
+                value = values[0].value.clone().into_value(tag);
+            }
+        }
+
+        Ok(futures::stream::iter(
+            input
+                .into_iter()
+                .chain(vec![value])
+                .map(ReturnSuccess::value),
+        )
+        .to_output_stream())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        use nu_protocol::row;
+
+        vec![
+            Example {
+                description: "Add values to the end of the table",
+                example: "echo [1 2 3] | append 4",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(2).into(),
+                    UntaggedValue::int(3).into(),
+                    UntaggedValue::int(4).into(),
+                ]),
+            },
+            Example {
+                description: "Add row value to the end of the table",
+                example: "echo [[country]; [Ecuador] ['New Zealand']] | append [[country]; [USA]]",
+                result: Some(vec![
+                    row! { "country".into() => Value::from("Ecuador")},
+                    row! { "country".into() => Value::from("New Zealand")},
+                    row! { "country".into() => Value::from("USA")},
+                ]),
+            },
+        ]
+    }
+}

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

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

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

@@ -0,0 +1,91 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+use serde::Deserialize;
+use serde::Serialize;
+use sha2::{Digest, Sha256};
+use std::io::Read;
+use std::path::{Path, PathBuf};
+pub struct Autoenv;
+
+#[derive(Deserialize, Serialize, Debug, Default)]
+pub struct Trusted {
+    pub files: IndexMap<String, Vec<u8>>,
+}
+impl Trusted {
+    pub fn new() -> Self {
+        Trusted {
+            files: IndexMap::new(),
+        }
+    }
+}
+pub fn file_is_trusted(nu_env_file: &Path, content: &[u8]) -> Result<bool, ShellError> {
+    let contentdigest = Sha256::digest(&content).as_slice().to_vec();
+    let nufile = std::fs::canonicalize(nu_env_file)?;
+
+    let trusted = read_trusted()?;
+
+    Ok(trusted.files.get(&nufile.to_string_lossy().to_string()) == Some(&contentdigest))
+}
+
+pub fn read_trusted() -> Result<Trusted, ShellError> {
+    let config_path = config::default_path_for(&Some(PathBuf::from("nu-env.toml")))?;
+
+    let mut file = std::fs::OpenOptions::new()
+        .read(true)
+        .create(true)
+        .write(true)
+        .open(config_path)
+        .map_err(|_| ShellError::untagged_runtime_error("Couldn't open nu-env.toml"))?;
+    let mut doc = String::new();
+    file.read_to_string(&mut doc)?;
+
+    let allowed = toml::de::from_str(doc.as_str()).unwrap_or_else(|_| Trusted::new());
+    Ok(allowed)
+}
+
+#[async_trait]
+impl WholeStreamCommand for Autoenv {
+    fn name(&self) -> &str {
+        "autoenv"
+    }
+    fn usage(&self) -> &str {
+        "Manage directory specific environment variables and scripts."
+    }
+
+    fn extra_usage(&self) -> &str {
+        // "Mark a .nu-env file in a directory as trusted. Needs to be re-run after each change to the file or its filepath."
+        r#"Create a file called .nu-env in any directory and run 'autoenv trust' to let nushell read it when entering the directory.
+The file can contain several optional sections:
+    env: environment variables to set when visiting the directory. The variables are unset after leaving the directory and any overwritten values are restored.
+    scriptvars: environment variables that should be set to the return value of a script. After they have been set, they behave in the same way as variables set in the env section.
+    scripts: scripts to run when entering the directory or leaving it."#
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("autoenv")
+    }
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(get_full_help(&Autoenv, &args.scope)).into_value(Tag::unknown()),
+        )))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Example .nu-env file",
+            example: r#"cat .nu-env
+        [env]
+        mykey = "myvalue"
+
+        [scriptvars]
+        myscript = "echo myval"
+
+        [scripts]
+        entryscripts = ["touch hello.txt", "touch hello2.txt"]
+        exitscripts = ["touch bye.txt"]"#,
+            result: None,
+        }]
+    }
+}

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

@@ -0,0 +1,80 @@
+use super::autoenv::read_trusted;
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::SyntaxShape;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+use sha2::{Digest, Sha256};
+use std::{fs, path::PathBuf};
+pub struct AutoenvTrust;
+
+#[async_trait]
+impl WholeStreamCommand for AutoenvTrust {
+    fn name(&self) -> &str {
+        "autoenv trust"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("autoenv trust").optional("dir", SyntaxShape::String, "Directory to allow")
+    }
+
+    fn usage(&self) -> &str {
+        "Trust a .nu-env file in the current or given directory"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let ctx = EvaluationContext::from_args(&args);
+
+        let file_to_trust = match args.call_info.evaluate(&ctx).await?.args.nth(0) {
+            Some(Value {
+                value: UntaggedValue::Primitive(Primitive::String(ref path)),
+                tag: _,
+            }) => {
+                let mut dir = fs::canonicalize(path)?;
+                dir.push(".nu-env");
+                dir
+            }
+            _ => {
+                let mut dir = fs::canonicalize(std::env::current_dir()?)?;
+                dir.push(".nu-env");
+                dir
+            }
+        };
+
+        let content = std::fs::read(&file_to_trust)?;
+
+        let filename = file_to_trust.to_string_lossy().to_string();
+        let mut allowed = read_trusted()?;
+        allowed
+            .files
+            .insert(filename, Sha256::digest(&content).as_slice().to_vec());
+
+        let config_path = config::default_path_for(&Some(PathBuf::from("nu-env.toml")))?;
+        let tomlstr = toml::to_string(&allowed).map_err(|_| {
+            ShellError::untagged_runtime_error("Couldn't serialize allowed dirs to nu-env.toml")
+        })?;
+        fs::write(config_path, tomlstr).expect("Couldn't write to toml file");
+
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(".nu-env trusted!").into_value(tag),
+        )))
+    }
+    fn is_binary(&self) -> bool {
+        false
+    }
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Allow .nu-env file in current directory",
+                example: "autoenv trust",
+                result: None,
+            },
+            Example {
+                description: "Allow .nu-env file in directory foo",
+                example: "autoenv trust foo",
+                result: None,
+            },
+        ]
+    }
+}

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

@@ -0,0 +1,104 @@
+use super::autoenv::Trusted;
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::SyntaxShape;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+use std::io::Read;
+use std::{fs, path::PathBuf};
+pub struct AutoenvUnTrust;
+
+#[async_trait]
+impl WholeStreamCommand for AutoenvUnTrust {
+    fn name(&self) -> &str {
+        "autoenv untrust"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("autoenv untrust").optional(
+            "dir",
+            SyntaxShape::String,
+            "Directory to disallow",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Untrust a .nu-env file in the current or given directory"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let ctx = EvaluationContext::from_args(&args);
+        let file_to_untrust = match args.call_info.evaluate(&ctx).await?.args.nth(0) {
+            Some(Value {
+                value: UntaggedValue::Primitive(Primitive::String(ref path)),
+                tag: _,
+            }) => {
+                let mut dir = fs::canonicalize(path)?;
+                dir.push(".nu-env");
+                dir
+            }
+            _ => {
+                let mut dir = std::env::current_dir()?;
+                dir.push(".nu-env");
+                dir
+            }
+        };
+
+        let config_path = config::default_path_for(&Some(PathBuf::from("nu-env.toml")))?;
+
+        let mut file = match std::fs::OpenOptions::new()
+            .read(true)
+            .create(true)
+            .write(true)
+            .open(config_path.clone())
+        {
+            Ok(p) => p,
+            Err(_) => {
+                return Err(ShellError::untagged_runtime_error(
+                    "Couldn't open nu-env.toml",
+                ));
+            }
+        };
+
+        let mut doc = String::new();
+        file.read_to_string(&mut doc)?;
+
+        let mut allowed: Trusted = toml::from_str(doc.as_str()).unwrap_or_else(|_| Trusted::new());
+
+        let file_to_untrust = file_to_untrust.to_string_lossy().to_string();
+
+        if allowed.files.remove(&file_to_untrust).is_none() {
+            return
+                Err(ShellError::untagged_runtime_error(
+                    "No .nu-env file to untrust in the given directory. Is it missing, or already untrusted?",
+                ));
+        }
+
+        let tomlstr = toml::to_string(&allowed).map_err(|_| {
+            ShellError::untagged_runtime_error("Couldn't serialize allowed dirs to nu-env.toml")
+        })?;
+        fs::write(config_path, tomlstr).expect("Couldn't write to toml file");
+
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(".nu-env untrusted!").into_value(tag),
+        )))
+    }
+    fn is_binary(&self) -> bool {
+        false
+    }
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Disallow .nu-env file in current directory",
+                example: "autoenv untrust",
+                result: None,
+            },
+            Example {
+                description: "Disallow .nu-env file in directory foo",
+                example: "autoenv untrust foo",
+                result: None,
+            },
+        ]
+    }
+}

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

@@ -0,0 +1,321 @@
+use crate::commands::autoview::options::{ConfigExtensions, NuConfig as AutoViewConfiguration};
+use crate::prelude::*;
+use crate::primitive::get_color_config;
+use nu_data::value::format_leaf;
+use nu_engine::{UnevaluatedCallInfo, WholeStreamCommand};
+use nu_errors::ShellError;
+use nu_protocol::hir::{self, Expression, ExternalRedirection, Literal, SpannedExpression};
+use nu_protocol::{Primitive, Signature, UntaggedValue, Value};
+use nu_table::TextStyle;
+use parking_lot::Mutex;
+use std::sync::atomic::AtomicBool;
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "autoview"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("autoview")
+    }
+
+    fn usage(&self) -> &str {
+        "View the contents of the pipeline as a table or list."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        autoview(RunnableContext {
+            input: args.input,
+            scope: args.scope.clone(),
+            shell_manager: args.shell_manager,
+            host: args.host,
+            ctrl_c: args.ctrl_c,
+            current_errors: args.current_errors,
+            name: args.call_info.name_tag,
+        })
+        .await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Automatically view the results",
+                example: "ls | autoview",
+                result: None,
+            },
+            Example {
+                description: "Autoview is also implied. The above can be written as",
+                example: "ls",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub struct RunnableContextWithoutInput {
+    pub shell_manager: ShellManager,
+    pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
+    pub current_errors: Arc<Mutex<Vec<ShellError>>>,
+    pub ctrl_c: Arc<AtomicBool>,
+    pub scope: Scope,
+    pub name: Tag,
+}
+
+impl RunnableContextWithoutInput {
+    pub fn convert(context: RunnableContext) -> (InputStream, RunnableContextWithoutInput) {
+        let new_context = RunnableContextWithoutInput {
+            shell_manager: context.shell_manager,
+            host: context.host,
+            ctrl_c: context.ctrl_c,
+            current_errors: context.current_errors,
+            scope: context.scope,
+            name: context.name,
+        };
+        (context.input, new_context)
+    }
+}
+
+pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellError> {
+    let configuration = AutoViewConfiguration::new();
+
+    let binary = context.get_command("binaryview");
+    let text = context.get_command("textview");
+    let table = context.get_command("table");
+
+    let pivot_mode = configuration.pivot_mode();
+
+    let (mut input_stream, context) = RunnableContextWithoutInput::convert(context);
+    let term_width = context.host.lock().width();
+    let color_hm = get_color_config();
+
+    if let Some(x) = input_stream.next().await {
+        match input_stream.next().await {
+            Some(y) => {
+                let ctrl_c = context.ctrl_c.clone();
+                let xy = vec![x, y];
+                let xy_stream = futures::stream::iter(xy)
+                    .chain(input_stream)
+                    .interruptible(ctrl_c);
+
+                let stream = InputStream::from_stream(xy_stream);
+
+                if let Some(table) = table {
+                    let command_args = create_default_command_args(&context).with_input(stream);
+                    let result = table.run(command_args).await?;
+                    result.collect::<Vec<_>>().await;
+                }
+            }
+            _ => {
+                match x {
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::String(ref s)),
+                        tag: Tag { anchor, span },
+                    } if anchor.is_some() => {
+                        if let Some(text) = text {
+                            let mut stream = VecDeque::new();
+                            stream.push_back(
+                                UntaggedValue::string(s).into_value(Tag { anchor, span }),
+                            );
+                            let command_args =
+                                create_default_command_args(&context).with_input(stream);
+                            let result = text.run(command_args).await?;
+                            result.collect::<Vec<_>>().await;
+                        } else {
+                            out!("{}", s);
+                        }
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::String(s)),
+                        ..
+                    } => {
+                        out!("{}", s);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::FilePath(s)),
+                        ..
+                    } => {
+                        out!("{}", s.display());
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Int(n)),
+                        ..
+                    } => {
+                        out!("{}", n);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Decimal(n)),
+                        ..
+                    } => {
+                        // TODO: normalize decimal to remove trailing zeros.
+                        // normalization will be available in next release of bigdecimal crate
+                        let mut output = n.to_string();
+                        if output.contains('.') {
+                            output = output.trim_end_matches('0').to_owned();
+                        }
+                        if output.ends_with('.') {
+                            output.push('0');
+                        }
+                        out!("{}", output);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Boolean(b)),
+                        ..
+                    } => {
+                        out!("{}", b);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Duration(_)),
+                        ..
+                    } => {
+                        let output = format_leaf(&x).plain_string(100_000);
+                        out!("{}", output);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Filesize(_)),
+                        ..
+                    } => {
+                        let output = format_leaf(&x).plain_string(100_000);
+                        out!("{}", output);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Date(d)),
+                        ..
+                    } => {
+                        out!("{}", d);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Range(_)),
+                        ..
+                    } => {
+                        let output = format_leaf(&x).plain_string(100_000);
+                        out!("{}", output);
+                    }
+
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Binary(ref b)),
+                        ..
+                    } => {
+                        if let Some(binary) = binary {
+                            let mut stream = VecDeque::new();
+                            stream.push_back(x);
+                            let command_args =
+                                create_default_command_args(&context).with_input(stream);
+                            let result = binary.run(command_args).await?;
+                            result.collect::<Vec<_>>().await;
+                        } else {
+                            use pretty_hex::*;
+                            out!("{:?}", b.hex_dump());
+                        }
+                    }
+
+                    Value {
+                        value: UntaggedValue::Error(e),
+                        ..
+                    } => {
+                        return Err(e);
+                    }
+
+                    Value {
+                        value: UntaggedValue::Row(row),
+                        ..
+                    } if pivot_mode.is_always()
+                        || (pivot_mode.is_auto()
+                            && (row
+                                .entries
+                                .iter()
+                                .map(|(_, v)| v.convert_to_string())
+                                .collect::<Vec<_>>()
+                                .iter()
+                                .fold(0usize, |acc, len| acc + len.len())
+                                + row.entries.iter().count() * 2)
+                                > term_width) =>
+                    {
+                        let mut entries = vec![];
+                        for (key, value) in row.entries.iter() {
+                            entries.push(vec![
+                                nu_table::StyledString::new(
+                                    key.to_string(),
+                                    TextStyle::new()
+                                        .alignment(nu_table::Alignment::Left)
+                                        .fg(nu_ansi_term::Color::Green)
+                                        .bold(Some(true)),
+                                ),
+                                nu_table::StyledString::new(
+                                    format_leaf(value).plain_string(100_000),
+                                    nu_table::TextStyle::basic_left(),
+                                ),
+                            ]);
+                        }
+
+                        let table =
+                            nu_table::Table::new(vec![], entries, nu_table::Theme::compact());
+
+                        println!("{}", nu_table::draw_table(&table, term_width, &color_hm));
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Nothing),
+                        ..
+                    } => {
+                        // Do nothing
+                    }
+                    Value {
+                        value: ref item, ..
+                    } => {
+                        if let Some(table) = table {
+                            let mut stream = VecDeque::new();
+                            stream.push_back(x);
+                            let command_args =
+                                create_default_command_args(&context).with_input(stream);
+                            let result = table.run(command_args).await?;
+                            result.collect::<Vec<_>>().await;
+                        } else {
+                            out!("{:?}", item);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(OutputStream::empty())
+}
+
+fn create_default_command_args(context: &RunnableContextWithoutInput) -> RawCommandArgs {
+    let span = context.name.span;
+    RawCommandArgs {
+        host: context.host.clone(),
+        ctrl_c: context.ctrl_c.clone(),
+        current_errors: context.current_errors.clone(),
+        shell_manager: context.shell_manager.clone(),
+        call_info: UnevaluatedCallInfo {
+            args: hir::Call {
+                head: Box::new(SpannedExpression::new(
+                    Expression::Literal(Literal::String(String::new())),
+                    span,
+                )),
+                positional: None,
+                named: None,
+                span,
+                external_redirection: ExternalRedirection::Stdout,
+            },
+            name_tag: context.name.clone(),
+        },
+        scope: Scope::new(),
+    }
+}
+
+#[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/autoview/mod.rs

@@ -0,0 +1,4 @@
+pub mod command;
+mod options;
+
+pub use command::Command as Autoview;

crates/nu-command/src/commands/autoview/options.rs

@@ -0,0 +1,51 @@
+pub use nu_data::config::NuConfig;
+use std::fmt::Debug;
+
+#[derive(PartialEq, Debug)]
+pub enum AutoPivotMode {
+    Auto,
+    Always,
+    Never,
+}
+
+impl AutoPivotMode {
+    pub fn is_auto(&self) -> bool {
+        matches!(self, AutoPivotMode::Auto)
+    }
+
+    pub fn is_always(&self) -> bool {
+        matches!(self, AutoPivotMode::Always)
+    }
+
+    #[allow(unused)]
+    pub fn is_never(&self) -> bool {
+        matches!(self, AutoPivotMode::Never)
+    }
+}
+
+pub trait ConfigExtensions: Debug + Send {
+    fn pivot_mode(&self) -> AutoPivotMode;
+}
+
+pub fn pivot_mode(config: &NuConfig) -> AutoPivotMode {
+    let vars = &config.vars;
+
+    if let Some(mode) = vars.get("pivot_mode") {
+        let mode = match mode.as_string() {
+            Ok(m) if m.to_lowercase() == "auto" => AutoPivotMode::Auto,
+            Ok(m) if m.to_lowercase() == "always" => AutoPivotMode::Always,
+            Ok(m) if m.to_lowercase() == "never" => AutoPivotMode::Never,
+            _ => AutoPivotMode::Never,
+        };
+
+        return mode;
+    }
+
+    AutoPivotMode::Never
+}
+
+impl ConfigExtensions for NuConfig {
+    fn pivot_mode(&self) -> AutoPivotMode {
+        pivot_mode(self)
+    }
+}

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

@@ -0,0 +1,210 @@
+use crate::prelude::*;
+// #[cfg(feature = "rich-benchmark")]
+// use heim::cpu::time;
+use nu_engine::run_block;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::{Block, CapturedBlock, ClassifiedCommand, Group, InternalCommand, Pipeline},
+    Dictionary, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use rand::{
+    distributions::Alphanumeric,
+    prelude::{thread_rng, Rng},
+};
+use std::convert::TryInto;
+use std::time::{Duration, Instant};
+
+pub struct Benchmark;
+
+#[derive(Deserialize, Debug)]
+struct BenchmarkArgs {
+    block: CapturedBlock,
+    passthrough: Option<CapturedBlock>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Benchmark {
+    fn name(&self) -> &str {
+        "benchmark"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("benchmark")
+            .required(
+                "block",
+                SyntaxShape::Block,
+                "the block to run and benchmark",
+            )
+            .named(
+                "passthrough",
+                SyntaxShape::Block,
+                "Display the benchmark results and pass through the block's output",
+                Some('p'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block and returns the time it took to execute it."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        benchmark(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Benchmarks a command within a block",
+                example: "benchmark { sleep 500ms }",
+                result: None,
+            },
+            Example {
+                description: "Benchmarks a command within a block and passes its output through",
+                example: "echo 45 | benchmark { sleep 500ms } --passthrough {}",
+                result: Some(vec![UntaggedValue::int(45).into()]),
+            },
+        ]
+    }
+}
+
+async fn benchmark(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = raw_args.call_info.args.span;
+    let mut context = EvaluationContext::from_args(&raw_args);
+    let scope = raw_args.scope.clone();
+    let (BenchmarkArgs { block, passthrough }, input) = raw_args.process().await?;
+
+    let env = scope.get_env_vars();
+    let name = generate_free_name(&env);
+
+    scope.add_env_var(name, generate_random_env_value());
+
+    let start_time = Instant::now();
+
+    // #[cfg(feature = "rich-benchmark")]
+    // let start = time().await;
+
+    context.scope.enter_scope();
+    let result = run_block(&block.block, &context, input).await;
+    context.scope.exit_scope();
+    let output = result?.into_vec().await;
+
+    // #[cfg(feature = "rich-benchmark")]
+    // let end = time().await;
+
+    let end_time = Instant::now();
+    context.clear_errors();
+
+    // return basic runtime
+    //#[cfg(not(feature = "rich-benchmark"))]
+    {
+        let mut indexmap = IndexMap::with_capacity(1);
+
+        let real_time = into_big_int(end_time - start_time);
+        indexmap.insert("real time".to_string(), real_time);
+        benchmark_output(indexmap, output, passthrough, &tag, &mut context).await
+    }
+    // return advanced stats
+    // #[cfg(feature = "rich-benchmark")]
+    // if let (Ok(start), Ok(end)) = (start, end) {
+    //     let mut indexmap = IndexMap::with_capacity(4);
+
+    //     let real_time = into_big_int(end_time - start_time);
+    //     indexmap.insert("real time".to_string(), real_time);
+
+    //     let user_time = into_big_int(end.user() - start.user());
+    //     indexmap.insert("user time".to_string(), user_time);
+
+    //     let system_time = into_big_int(end.system() - start.system());
+    //     indexmap.insert("system time".to_string(), system_time);
+
+    //     let idle_time = into_big_int(end.idle() - start.idle());
+    //     indexmap.insert("idle time".to_string(), idle_time);
+
+    //     benchmark_output(indexmap, output, passthrough, &tag, &mut context).await
+    // } else {
+    //     Err(ShellError::untagged_runtime_error(
+    //         "Could not retrieve CPU time",
+    //     ))
+    // }
+}
+
+async fn benchmark_output<T, Output>(
+    indexmap: IndexMap<String, BigInt>,
+    block_output: Output,
+    passthrough: Option<CapturedBlock>,
+    tag: T,
+    context: &mut EvaluationContext,
+) -> Result<OutputStream, ShellError>
+where
+    T: Into<Tag> + Copy,
+    Output: Into<OutputStream>,
+{
+    let value = UntaggedValue::Row(Dictionary::from(
+        indexmap
+            .into_iter()
+            .map(|(k, v)| (k, UntaggedValue::duration(v).into_value(tag)))
+            .collect::<IndexMap<String, Value>>(),
+    ))
+    .into_value(tag);
+
+    if let Some(time_block) = passthrough {
+        let benchmark_output = InputStream::one(value);
+
+        // add autoview for an empty block
+        let time_block = add_implicit_autoview(time_block.block);
+
+        context.scope.enter_scope();
+        let result = run_block(&time_block, context, benchmark_output).await;
+        context.scope.exit_scope();
+        result?;
+        context.clear_errors();
+
+        Ok(block_output.into())
+    } else {
+        let benchmark_output = OutputStream::one(value);
+        Ok(benchmark_output)
+    }
+}
+
+fn add_implicit_autoview(mut block: Block) -> Block {
+    if block.block.is_empty() {
+        let group = Group::new(
+            vec![{
+                let mut commands = Pipeline::new(block.span);
+                commands.push(ClassifiedCommand::Internal(InternalCommand::new(
+                    "autoview".to_string(),
+                    block.span,
+                    block.span,
+                )));
+                commands
+            }],
+            block.span,
+        );
+        block.push(group);
+    }
+    block
+}
+
+fn into_big_int<T: TryInto<Duration>>(time: T) -> BigInt {
+    time.try_into()
+        .unwrap_or_else(|_| Duration::new(0, 0))
+        .as_nanos()
+        .into()
+}
+
+fn generate_random_env_value() -> String {
+    let mut thread_rng = thread_rng();
+    let len = thread_rng.gen_range(1, 16 * 1024);
+    thread_rng.sample_iter(&Alphanumeric).take(len).collect()
+}
+
+fn generate_free_name(env: &indexmap::IndexMap<String, String>) -> String {
+    let mut thread_rng = thread_rng();
+    loop {
+        let candidate_name = format!("NU_RANDOM_VALUE_{}", thread_rng.gen::<usize>());
+        if !env.contains_key(&candidate_name) {
+            return candidate_name;
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+use crate::prelude::*;
+use nu_errors::ShellError;
+
+use nu_data::value::format_leaf;
+use nu_engine::WholeStreamCommand;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+#[derive(Deserialize)]
+pub struct BuildStringArgs {
+    rest: Vec<Value>,
+}
+
+pub struct BuildString;
+
+#[async_trait]
+impl WholeStreamCommand for BuildString {
+    fn name(&self) -> &str {
+        "build-string"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("build-string")
+            .rest(SyntaxShape::Any, "all values to form into the string")
+    }
+
+    fn usage(&self) -> &str {
+        "Builds a string from the arguments."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let (BuildStringArgs { rest }, _) = args.process().await?;
+
+        let mut output_string = String::new();
+
+        for r in rest {
+            output_string.push_str(&format_leaf(&r).plain_string(100_000))
+        }
+
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(output_string).into_value(tag),
+        )))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Builds a string from a string and a number, without spaces between them",
+            example: "build-string 'foo' 3",
+            result: None,
+        }]
+    }
+}

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

@@ -0,0 +1,342 @@
+use crate::prelude::*;
+use chrono::{Datelike, Local, NaiveDate};
+use indexmap::IndexMap;
+use nu_engine::{EvaluatedWholeStreamCommandArgs, WholeStreamCommand};
+use nu_errors::ShellError;
+use nu_protocol::{Dictionary, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct Cal;
+
+#[async_trait]
+impl WholeStreamCommand for Cal {
+    fn name(&self) -> &str {
+        "cal"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("cal")
+            .switch("year", "Display the year column", Some('y'))
+            .switch("quarter", "Display the quarter column", Some('q'))
+            .switch("month", "Display the month column", Some('m'))
+            .named(
+                "full-year",
+                SyntaxShape::Int,
+                "Display a year-long calendar for the specified year",
+                None,
+            )
+            .named(
+                "week-start",
+                SyntaxShape::String,
+                "Display the calendar with the specified day as the first day of the week",
+                None,
+            )
+            .switch(
+                "month-names",
+                "Display the month names instead of integers",
+                None,
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Display a calendar."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        cal(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "This month's calendar",
+                example: "cal",
+                result: None,
+            },
+            Example {
+                description: "The calendar for all of 2012",
+                example: "cal --full-year 2012",
+                result: None,
+            },
+            Example {
+                description: "This month's calendar with the week starting on monday",
+                example: "cal --week-start monday",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn cal(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let mut calendar_vec_deque = VecDeque::new();
+    let tag = args.call_info.name_tag.clone();
+
+    let (current_year, current_month, current_day) = get_current_date();
+
+    let mut selected_year: i32 = current_year;
+    let mut current_day_option: Option<u32> = Some(current_day);
+
+    let month_range = if let Some(full_year_value) = args.get("full-year") {
+        if let Ok(year_u64) = full_year_value.as_u64() {
+            selected_year = year_u64 as i32;
+
+            if selected_year != current_year {
+                current_day_option = None
+            }
+        } else {
+            return Err(get_invalid_year_shell_error(&full_year_value.tag()));
+        }
+
+        (1, 12)
+    } else {
+        (current_month, current_month)
+    };
+
+    add_months_of_year_to_table(
+        &args,
+        &mut calendar_vec_deque,
+        &tag,
+        selected_year,
+        month_range,
+        current_month,
+        current_day_option,
+    )?;
+
+    Ok(futures::stream::iter(calendar_vec_deque).to_output_stream())
+}
+
+fn get_invalid_year_shell_error(year_tag: &Tag) -> ShellError {
+    ShellError::labeled_error("The year is invalid", "invalid year", year_tag)
+}
+
+struct MonthHelper {
+    selected_year: i32,
+    selected_month: u32,
+    day_number_of_week_month_starts_on: u32,
+    number_of_days_in_month: u32,
+    quarter_number: u32,
+    month_name: String,
+}
+
+impl MonthHelper {
+    pub fn new(selected_year: i32, selected_month: u32) -> Result<MonthHelper, ()> {
+        let naive_date = NaiveDate::from_ymd_opt(selected_year, selected_month, 1).ok_or(())?;
+        let number_of_days_in_month =
+            MonthHelper::calculate_number_of_days_in_month(selected_year, selected_month)?;
+
+        Ok(MonthHelper {
+            selected_year,
+            selected_month,
+            day_number_of_week_month_starts_on: naive_date.weekday().num_days_from_sunday(),
+            number_of_days_in_month,
+            quarter_number: ((selected_month - 1) / 3) + 1,
+            month_name: naive_date.format("%B").to_string().to_ascii_lowercase(),
+        })
+    }
+
+    fn calculate_number_of_days_in_month(
+        mut selected_year: i32,
+        mut selected_month: u32,
+    ) -> Result<u32, ()> {
+        // Chrono does not provide a method to output the amount of days in a month
+        // This is a workaround taken from the example code from the Chrono docs here:
+        // https://docs.rs/chrono/0.3.0/chrono/naive/date/struct.NaiveDate.html#example-30
+        if selected_month == 12 {
+            selected_year += 1;
+            selected_month = 1;
+        } else {
+            selected_month += 1;
+        };
+
+        let next_month_naive_date =
+            NaiveDate::from_ymd_opt(selected_year, selected_month, 1).ok_or(())?;
+
+        Ok(next_month_naive_date.pred().day())
+    }
+}
+
+fn get_current_date() -> (i32, u32, u32) {
+    let local_now_date = Local::now().date();
+
+    let current_year: i32 = local_now_date.year();
+    let current_month: u32 = local_now_date.month();
+    let current_day: u32 = local_now_date.day();
+
+    (current_year, current_month, current_day)
+}
+
+fn add_months_of_year_to_table(
+    args: &EvaluatedWholeStreamCommandArgs,
+    mut calendar_vec_deque: &mut VecDeque<Value>,
+    tag: &Tag,
+    selected_year: i32,
+    (start_month, end_month): (u32, u32),
+    current_month: u32,
+    current_day_option: Option<u32>,
+) -> Result<(), ShellError> {
+    for month_number in start_month..=end_month {
+        let mut new_current_day_option: Option<u32> = None;
+
+        if let Some(current_day) = current_day_option {
+            if month_number == current_month {
+                new_current_day_option = Some(current_day)
+            }
+        }
+
+        let add_month_to_table_result = add_month_to_table(
+            &args,
+            &mut calendar_vec_deque,
+            &tag,
+            selected_year,
+            month_number,
+            new_current_day_option,
+        );
+
+        add_month_to_table_result?
+    }
+
+    Ok(())
+}
+
+fn add_month_to_table(
+    args: &EvaluatedWholeStreamCommandArgs,
+    calendar_vec_deque: &mut VecDeque<Value>,
+    tag: &Tag,
+    selected_year: i32,
+    current_month: u32,
+    current_day_option: Option<u32>,
+) -> Result<(), ShellError> {
+    let month_helper_result = MonthHelper::new(selected_year, current_month);
+
+    let month_helper = match month_helper_result {
+        Ok(month_helper) => month_helper,
+        Err(()) => match args.get("full-year") {
+            Some(full_year_value) => {
+                return Err(get_invalid_year_shell_error(&full_year_value.tag()))
+            }
+            None => {
+                return Err(ShellError::labeled_error(
+                    "Issue parsing command",
+                    "invalid command",
+                    tag,
+                ))
+            }
+        },
+    };
+
+    let mut days_of_the_week = [
+        "sunday",
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+    ];
+
+    let mut week_start_day = days_of_the_week[0].to_string();
+
+    if let Some(week_start_value) = args.get("week-start") {
+        if let Ok(day) = week_start_value.as_string() {
+            if days_of_the_week.contains(&day.as_str()) {
+                week_start_day = day;
+            } else {
+                return Err(ShellError::labeled_error(
+                    "The specified week start day is invalid",
+                    "invalid week start day",
+                    week_start_value.tag(),
+                ));
+            }
+        }
+    }
+
+    let week_start_day_offset = days_of_the_week.len()
+        - days_of_the_week
+            .iter()
+            .position(|day| *day == week_start_day)
+            .unwrap_or(0);
+
+    days_of_the_week.rotate_right(week_start_day_offset);
+
+    let mut total_start_offset: u32 =
+        month_helper.day_number_of_week_month_starts_on + week_start_day_offset as u32;
+    total_start_offset %= days_of_the_week.len() as u32;
+
+    let mut day_number: u32 = 1;
+    let day_limit: u32 = total_start_offset + month_helper.number_of_days_in_month;
+
+    let should_show_year_column = args.has("year");
+    let should_show_quarter_column = args.has("quarter");
+    let should_show_month_column = args.has("month");
+    let should_show_month_names = args.has("month-names");
+
+    while day_number <= day_limit {
+        let mut indexmap = IndexMap::new();
+
+        if should_show_year_column {
+            indexmap.insert(
+                "year".to_string(),
+                UntaggedValue::int(month_helper.selected_year).into_value(tag),
+            );
+        }
+
+        if should_show_quarter_column {
+            indexmap.insert(
+                "quarter".to_string(),
+                UntaggedValue::int(month_helper.quarter_number).into_value(tag),
+            );
+        }
+
+        if should_show_month_column || should_show_month_names {
+            let month_value = if should_show_month_names {
+                UntaggedValue::string(month_helper.month_name.clone()).into_value(tag)
+            } else {
+                UntaggedValue::int(month_helper.selected_month).into_value(tag)
+            };
+
+            indexmap.insert("month".to_string(), month_value);
+        }
+
+        for day in &days_of_the_week {
+            let should_add_day_number_to_table =
+                (day_number > total_start_offset) && (day_number <= day_limit);
+
+            let mut value = UntaggedValue::nothing().into_value(tag);
+
+            if should_add_day_number_to_table {
+                let adjusted_day_number = day_number - total_start_offset;
+
+                value = UntaggedValue::int(adjusted_day_number).into_value(tag);
+
+                if let Some(current_day) = current_day_option {
+                    if current_day == adjusted_day_number {
+                        // TODO: Update the value here with a color when color support is added
+                        // This colors the current day
+                    }
+                }
+            }
+
+            indexmap.insert((*day).to_string(), value);
+
+            day_number += 1;
+        }
+
+        calendar_vec_deque
+            .push_back(UntaggedValue::Row(Dictionary::from(indexmap)).into_value(tag));
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Cal;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Cal {})
+    }
+}

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

@@ -0,0 +1,72 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+
+use nu_engine::shell::CdArgs;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape};
+
+pub struct Cd;
+
+#[async_trait]
+impl WholeStreamCommand for Cd {
+    fn name(&self) -> &str {
+        "cd"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("cd").optional(
+            "directory",
+            SyntaxShape::FilePath,
+            "the directory to change to",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Change to a new path."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let name = args.call_info.name_tag.clone();
+        let shell_manager = args.shell_manager.clone();
+        let (args, _): (CdArgs, _) = args.process().await?;
+        shell_manager.cd(args, name)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Change to a new directory called 'dirname'",
+                example: "cd dirname",
+                result: None,
+            },
+            Example {
+                description: "Change to your home directory",
+                example: "cd",
+                result: None,
+            },
+            Example {
+                description: "Change to your home directory (alternate version)",
+                example: "cd ~",
+                result: None,
+            },
+            Example {
+                description: "Change to the previous directory",
+                example: "cd -",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Cd;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Cd {})
+    }
+}

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

@@ -0,0 +1,151 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct Char;
+
+#[derive(Deserialize)]
+struct CharArgs {
+    name: Tagged<String>,
+    unicode: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Char {
+    fn name(&self) -> &str {
+        "char"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("char")
+            .required(
+                "character",
+                SyntaxShape::Any,
+                "the name of the character to output",
+            )
+            .switch("unicode", "unicode string i.e. 1f378", Some('u'))
+    }
+
+    fn usage(&self) -> &str {
+        "Output special characters (eg. 'newline')."
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Output newline",
+                example: r#"char newline"#,
+                result: Some(vec![Value::from("\n")]),
+            },
+            Example {
+                description: "Output prompt character, newline and a hamburger character",
+                example: r#"echo $(char prompt) $(char newline) $(char hamburger)"#,
+                result: Some(vec![
+                    UntaggedValue::string("\u{25b6}").into(),
+                    UntaggedValue::string("\n").into(),
+                    UntaggedValue::string("\u{2261}").into(),
+                ]),
+            },
+            Example {
+                description: "Output unicode character",
+                example: r#"char -u 1f378"#,
+                result: Some(vec![Value::from("\u{1f378}")]),
+            },
+        ]
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let (CharArgs { name, unicode }, _) = args.process().await?;
+
+        if unicode {
+            let decoded_char = string_to_unicode_char(&name.item);
+            if let Some(output) = decoded_char {
+                Ok(OutputStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(output).into_value(name.tag()),
+                )))
+            } else {
+                Err(ShellError::labeled_error(
+                    "error decoding unicode character",
+                    "error decoding unicode character",
+                    name.tag(),
+                ))
+            }
+        } else {
+            let special_character = str_to_character(&name.item);
+            if let Some(output) = special_character {
+                Ok(OutputStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(output).into_value(name.tag()),
+                )))
+            } else {
+                Err(ShellError::labeled_error(
+                    "error finding named character",
+                    "error finding named character",
+                    name.tag(),
+                ))
+            }
+        }
+    }
+}
+
+fn string_to_unicode_char(s: &str) -> Option<char> {
+    u32::from_str_radix(s, 16)
+        .ok()
+        .and_then(std::char::from_u32)
+}
+
+fn str_to_character(s: &str) -> Option<String> {
+    match s {
+        "newline" | "enter" | "nl" => Some("\n".into()),
+        "tab" => Some("\t".into()),
+        "sp" | "space" => Some(" ".into()),
+        // Unicode names came from https://www.compart.com/en/unicode
+        // Private Use Area (U+E000-U+F8FF)
+        // Unicode can't be mixed with Ansi or it will break width calculation
+        "branch" => Some('\u{e0a0}'.to_string()),  // 
+        "segment" => Some('\u{e0b0}'.to_string()), // 
+
+        "identical_to" | "hamburger" => Some('\u{2261}'.to_string()), // ≡
+        "not_identical_to" | "branch_untracked" => Some('\u{2262}'.to_string()), // ≢
+        "strictly_equivalent_to" | "branch_identical" => Some('\u{2263}'.to_string()), // ≣
+
+        "upwards_arrow" | "branch_ahead" => Some('\u{2191}'.to_string()), // ↑
+        "downwards_arrow" | "branch_behind" => Some('\u{2193}'.to_string()), // ↓
+        "up_down_arrow" | "branch_ahead_behind" => Some('\u{2195}'.to_string()), // ↕
+
+        "black_right_pointing_triangle" | "prompt" => Some('\u{25b6}'.to_string()), // ▶
+        "vector_or_cross_product" | "failed" => Some('\u{2a2f}'.to_string()),       // ⨯
+        "high_voltage_sign" | "elevated" => Some('\u{26a1}'.to_string()),           // ⚡
+        "tilde" | "twiddle" | "squiggly" | "home" => Some("~".into()),              // ~
+        "hash" | "hashtag" | "pound_sign" | "sharp" | "root" => Some("#".into()),   // #
+
+        // Weather symbols
+        "sun" | "sunny" | "sunrise" => Some("☀️".to_string()),
+        "moon" => Some("🌛".to_string()),
+        "cloudy" | "cloud" | "clouds" => Some("☁️".to_string()),
+        "rainy" | "rain" => Some("🌦️".to_string()),
+        "foggy" | "fog" => Some("🌫️".to_string()),
+        "mist" | "haze" => Some("\u{2591}".to_string()),
+        "snowy" | "snow" => Some("❄️".to_string()),
+        "thunderstorm" | "thunder" => Some("🌩️".to_string()),
+
+        "bel" => Some('\x07'.to_string()),       // Terminal Bell
+        "backspace" => Some('\x08'.to_string()), // Backspace
+
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Char;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Char {})
+    }
+}

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

@@ -0,0 +1,47 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+#[derive(Clone)]
+pub struct Chart;
+
+#[async_trait]
+impl WholeStreamCommand for Chart {
+    fn name(&self) -> &str {
+        "chart"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("chart")
+    }
+
+    fn usage(&self) -> &str {
+        "Displays charts."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        if args.scope.get_command("chart bar").is_none() {
+            return Err(ShellError::untagged_runtime_error(
+                "nu_plugin_chart not installed.",
+            ));
+        }
+
+        Ok(OutputStream::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/classified/dynamic.rs

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

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

@@ -0,0 +1,682 @@
+use crate::futures::ThreadedReceiver;
+use crate::prelude::*;
+use nu_engine::evaluate_baseline_expr;
+use nu_engine::{MaybeTextCodec, StringOrBinary};
+
+use std::borrow::Cow;
+use std::io::Write;
+use std::ops::Deref;
+use std::process::{Command, Stdio};
+use std::sync::mpsc;
+
+use futures::executor::block_on_stream;
+use futures_codec::FramedRead;
+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;
+use nu_stream::trace_stream;
+
+pub(crate) async fn run_external_command(
+    command: ExternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+) -> Result<InputStream, ShellError> {
+    trace!(target: "nu::run::external", "-> {}", command.name);
+
+    if !did_find_command(&command.name) {
+        return Err(ShellError::labeled_error(
+            "Command not found",
+            "command not found",
+            &command.name_tag,
+        ));
+    }
+
+    run_with_stdin(command, context, input, external_redirection).await
+}
+
+async fn run_with_stdin(
+    command: ExternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+) -> Result<InputStream, ShellError> {
+    let path = context.shell_manager.path();
+
+    let input = trace_stream!(target: "nu::trace_stream::external::stdin", "input" = input);
+
+    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).await?;
+
+        // 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();
+                command_args.push((trimmed_value_string, is_literal));
+            }
+        }
+    }
+
+    let process_args = command_args
+        .iter()
+        .map(|(arg, _is_literal)| {
+            let home_dir;
+
+            #[cfg(feature = "dirs")]
+            {
+                home_dir = dirs_next::home_dir;
+            }
+            #[cfg(not(feature = "dirs"))]
+            {
+                home_dir = || Some(std::path::PathBuf::from("/"));
+            }
+
+            let arg = expand_tilde(arg.deref(), home_dir);
+
+            #[cfg(not(windows))]
+            {
+                if !_is_literal {
+                    let escaped = escape_double_quotes(&arg);
+                    add_double_quotes(&escaped)
+                } else {
+                    arg.as_ref().to_string()
+                }
+            }
+            #[cfg(windows)]
+            {
+                if let Some(unquoted) = remove_quotes(&arg) {
+                    unquoted.to_string()
+                } else {
+                    arg.as_ref().to_string()
+                }
+            }
+        })
+        .collect::<Vec<String>>();
+
+    spawn(
+        &command,
+        &path,
+        &process_args[..],
+        input,
+        external_redirection,
+        &context.scope,
+    )
+}
+
+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 = {
+        #[cfg(windows)]
+        {
+            let mut process = Command::new("cmd");
+            process.arg("/c");
+            process.arg(&command.name);
+            for arg in args {
+                // Clean the args before we use them:
+                let arg = arg.replace("|", "\\|");
+                process.arg(&arg);
+            }
+            process
+        }
+
+        #[cfg(not(windows))]
+        {
+            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
+        }
+    };
+
+    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
+    if let Ok(mut child) = process.spawn() {
+        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 block_on_stream(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()
+                                    ),
+                                    "expected a string",
+                                    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());
+
+                for line in block_on_stream(stream) {
+                    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());
+
+                for line in block_on_stream(stream) {
+                    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::Error(ShellError::external_non_zero()),
+                    tag: stdout_name_tag,
+                }));
+            }
+
+            Ok(())
+        });
+
+        let stream = ThreadedReceiver::new(rx);
+        Ok(stream.to_input_stream())
+    } else {
+        Err(ShellError::labeled_error(
+            "Failed to spawn process",
+            "failed to spawn",
+            &command.name_tag,
+        ))
+    }
+}
+
+pub fn did_find_command(#[allow(unused)] name: &str) -> bool {
+    #[cfg(not(feature = "which"))]
+    {
+        // we can't perform this check, so just assume it can be found
+        true
+    }
+
+    #[cfg(all(feature = "which", unix))]
+    {
+        which::which(name).is_ok()
+    }
+
+    #[cfg(all(feature = "which", windows))]
+    {
+        if which::which(name).is_ok() {
+            true
+        } else {
+            // Reference: https://ss64.com/nt/syntax-internal.html
+            let cmd_builtins = [
+                "assoc", "break", "color", "copy", "date", "del", "dir", "dpath", "echo", "erase",
+                "for", "ftype", "md", "mkdir", "mklink", "move", "path", "ren", "rename", "rd",
+                "rmdir", "start", "time", "title", "type", "ver", "verify", "vol",
+            ];
+
+            cmd_builtins.contains(&name)
+        }
+    }
+}
+
+fn expand_tilde<SI: ?Sized, P, HD>(input: &SI, home_dir: HD) -> std::borrow::Cow<str>
+where
+    SI: AsRef<str>,
+    P: AsRef<std::path::Path>,
+    HD: FnOnce() -> Option<P>,
+{
+    shellexpand::tilde_with_context(input, home_dir)
+}
+
+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("PATH") {
+        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, expand_tilde, remove_quotes,
+    };
+    #[cfg(feature = "which")]
+    use super::{run_external_command, InputStream};
+
+    #[cfg(feature = "which")]
+    use futures::executor::block_on;
+    #[cfg(feature = "which")]
+    use nu_engine::basic_evaluation_context;
+    #[cfg(feature = "which")]
+    use nu_errors::ShellError;
+    #[cfg(feature = "which")]
+    use nu_test_support::commands::ExternalBuilder;
+    // async fn read(mut stream: OutputStream) -> Option<Value> {
+    //     match stream.try_next().await {
+    //         Ok(val) => {
+    //             if let Some(val) = val {
+    //                 val.raw_value()
+    //             } else {
+    //                 None
+    //             }
+    //         }
+    //         Err(_) => None,
+    //     }
+    // }
+
+    #[cfg(feature = "which")]
+    async fn non_existent_run() -> Result<(), ShellError> {
+        use nu_protocol::hir::ExternalRedirection;
+        let cmd = ExternalBuilder::for_name("i_dont_exist.exe").build();
+
+        let input = InputStream::empty();
+        let mut ctx =
+            basic_evaluation_context().expect("There was a problem creating a basic context.");
+
+        assert!(
+            run_external_command(cmd, &mut ctx, input, ExternalRedirection::Stdout)
+                .await
+                .is_err()
+        );
+
+        Ok(())
+    }
+
+    // async fn failure_run() -> Result<(), ShellError> {
+    //     let cmd = ExternalBuilder::for_name("fail").build();
+
+    //     let mut ctx = crate::cli::basic_evaluation_context().expect("There was a problem creating a basic context.");
+    //     let stream = run_external_command(cmd, &mut ctx, None, false)
+    //         .await?
+    //         .expect("There was a problem running the external command.");
+
+    //     match read(stream.into()).await {
+    //         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() -> Result<(), ShellError> {
+        block_on(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_eq!(argument_is_quoted(""), false);
+
+        assert_eq!(argument_is_quoted("'"), false);
+        assert_eq!(argument_is_quoted("'a"), false);
+        assert_eq!(argument_is_quoted("a"), false);
+        assert_eq!(argument_is_quoted("a'"), false);
+        assert_eq!(argument_is_quoted("''"), true);
+
+        assert_eq!(argument_is_quoted(r#"""#), false);
+        assert_eq!(argument_is_quoted(r#""a"#), false);
+        assert_eq!(argument_is_quoted(r#"a"#), false);
+        assert_eq!(argument_is_quoted(r#"a""#), false);
+        assert_eq!(argument_is_quoted(r#""""#), true);
+
+        assert_eq!(argument_is_quoted("'andrés"), false);
+        assert_eq!(argument_is_quoted("andrés'"), false);
+        assert_eq!(argument_is_quoted(r#""andrés"#), false);
+        assert_eq!(argument_is_quoted(r#"andrés""#), false);
+        assert_eq!(argument_is_quoted("'andrés'"), true);
+        assert_eq!(argument_is_quoted(r#""andrés""#), true);
+    }
+
+    #[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"));
+    }
+
+    #[test]
+    fn expands_tilde_if_starts_with_tilde_character() {
+        assert_eq!(
+            expand_tilde("~", || Some(std::path::Path::new("the_path_to_nu_light"))),
+            "the_path_to_nu_light"
+        );
+    }
+
+    #[test]
+    fn does_not_expand_tilde_if_tilde_is_not_first_character() {
+        assert_eq!(
+            expand_tilde("1~1", || Some(std::path::Path::new("the_path_to_nu_light"))),
+            "1~1"
+        );
+    }
+}

crates/nu-command/src/commands/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/clear.rs

@@ -0,0 +1,45 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::Signature;
+use std::process::Command;
+
+pub struct Clear;
+
+#[async_trait]
+impl WholeStreamCommand for Clear {
+    fn name(&self) -> &str {
+        "clear"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("clear")
+    }
+
+    fn usage(&self) -> &str {
+        "Clears the terminal."
+    }
+
+    async fn run(&self, _: CommandArgs) -> Result<OutputStream, ShellError> {
+        if cfg!(windows) {
+            Command::new("cmd")
+                .args(&["/C", "cls"])
+                .status()
+                .expect("failed to execute process");
+        } else if cfg!(unix) {
+            Command::new("/bin/sh")
+                .args(&["-c", "clear"])
+                .status()
+                .expect("failed to execute process");
+        }
+        Ok(OutputStream::empty())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Clear the screen",
+            example: "clear",
+            result: None,
+        }]
+    }
+}

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

@@ -0,0 +1,106 @@
+use crate::prelude::*;
+use futures::stream::StreamExt;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, Value};
+
+use arboard::Clipboard;
+
+pub struct Clip;
+
+#[async_trait]
+impl WholeStreamCommand for Clip {
+    fn name(&self) -> &str {
+        "clip"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("clip")
+    }
+
+    fn usage(&self) -> &str {
+        "Copy the contents of the pipeline to the copy/paste buffer."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        clip(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Save text to the clipboard",
+                example: "echo 'secret value' | clip",
+                result: None,
+            },
+            Example {
+                description: "Save numbers to the clipboard",
+                example: "random integer 10000000..99999999 | clip",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn clip(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let input = args.input;
+    let name = args.call_info.name_tag.clone();
+    let values: Vec<Value> = input.collect().await;
+
+    if let Ok(mut clip_context) = Clipboard::new() {
+        let mut new_copy_data = String::new();
+
+        if !values.is_empty() {
+            let mut first = true;
+            for i in values.iter() {
+                if !first {
+                    new_copy_data.push('\n');
+                } else {
+                    first = false;
+                }
+
+                let string: String = i.convert_to_string();
+                if string.is_empty() {
+                    return Err(ShellError::labeled_error(
+                        "Unable to convert to string",
+                        "Unable to convert to string",
+                        name,
+                    ));
+                }
+
+                new_copy_data.push_str(&string);
+            }
+        }
+
+        match clip_context.set_text(new_copy_data) {
+            Ok(_) => {}
+            Err(_) => {
+                return Err(ShellError::labeled_error(
+                    "Could not set contents of clipboard",
+                    "could not set contents of clipboard",
+                    name,
+                ));
+            }
+        }
+    } else {
+        return Err(ShellError::labeled_error(
+            "Could not open clipboard",
+            "could not open clipboard",
+            name,
+        ));
+    }
+    Ok(OutputStream::empty())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Clip;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Clip {})
+    }
+}

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

@@ -0,0 +1,21 @@
+use crate::prelude::*;
+use nu_engine::Command;
+use nu_errors::ShellError;
+use parking_lot::Mutex;
+use std::sync::atomic::AtomicBool;
+
+pub struct RunnableContext {
+    pub input: InputStream,
+    pub shell_manager: ShellManager,
+    pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
+    pub ctrl_c: Arc<AtomicBool>,
+    pub current_errors: Arc<Mutex<Vec<ShellError>>>,
+    pub scope: Scope,
+    pub name: Tag,
+}
+
+impl RunnableContext {
+    pub fn get_command(&self, name: &str) -> Option<Command> {
+        self.scope.get_command(name)
+    }
+}

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

@@ -0,0 +1,86 @@
+use crate::prelude::*;
+use futures::future;
+use futures::stream::StreamExt;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct Compact;
+
+#[derive(Deserialize)]
+pub struct CompactArgs {
+    rest: Vec<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Compact {
+    fn name(&self) -> &str {
+        "compact"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("compact").rest(SyntaxShape::Any, "the columns to compact from the table")
+    }
+
+    fn usage(&self) -> &str {
+        "Creates a table with non-empty rows."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        compact(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Filter out all directory entries having no 'target'",
+            example: "ls -la | compact target",
+            result: None,
+        }]
+    }
+}
+
+pub async fn compact(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (CompactArgs { rest: columns }, input) = args.process().await?;
+    Ok(input
+        .filter_map(move |item| {
+            future::ready(if columns.is_empty() {
+                if !item.is_empty() {
+                    Some(ReturnSuccess::value(item))
+                } else {
+                    None
+                }
+            } else {
+                match item {
+                    Value {
+                        value: UntaggedValue::Row(ref r),
+                        ..
+                    } => {
+                        if columns
+                            .iter()
+                            .all(|field| r.get_data(field).borrow().is_some())
+                        {
+                            Some(ReturnSuccess::value(item))
+                        } else {
+                            None
+                        }
+                    }
+                    _ => None,
+                }
+            })
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Compact;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Compact {})
+    }
+}

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

@@ -0,0 +1,49 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct SubCommand;
+
+#[async_trait]
+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"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        clear(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Clear the config (be careful!)",
+            example: "config clear",
+            result: None,
+        }]
+    }
+}
+
+pub async fn clear(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_span = args.call_info.name_tag.clone();
+
+    // NOTE: None because we are not loading a new config file, we just want to read from the
+    // existing config
+    let mut result = nu_data::config::read(name_span, &None)?;
+
+    result.clear();
+
+    config::write(&result, &None)?;
+
+    Ok(OutputStream::one(ReturnSuccess::value(
+        UntaggedValue::Row(result.into()).into_value(args.call_info.name_tag),
+    )))
+}

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

@@ -0,0 +1,34 @@
+use crate::prelude::*;
+use nu_engine::CommandArgs;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+use nu_stream::OutputStream;
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "config"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config")
+    }
+
+    fn usage(&self) -> &str {
+        "Configuration management."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let name_span = args.call_info.name_tag.clone();
+        let name = args.call_info.name_tag;
+        let result = nu_data::config::read(name_span, &None)?;
+
+        Ok(futures::stream::iter(vec![ReturnSuccess::value(
+            UntaggedValue::Row(result.into()).into_value(name),
+        )])
+        .to_output_stream())
+    }
+}

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

@@ -0,0 +1,68 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+pub struct GetArgs {
+    path: ColumnPath,
+}
+
+#[async_trait]
+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"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        get(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the current startup commands",
+            example: "config get startup",
+            result: None,
+        }]
+    }
+}
+
+pub async fn get(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_tag = args.call_info.name_tag.clone();
+    let (GetArgs { path }, _) = args.process().await?;
+
+    // NOTE: None because we are not loading a new config file, we just want to read from the
+    // existing config
+    let result = UntaggedValue::row(nu_data::config::read(&name_tag, &None)?).into_value(&name_tag);
+
+    let value = crate::commands::get::get_column_path(&path, &result)?;
+
+    Ok(match value {
+        Value {
+            value: UntaggedValue::Table(list),
+            ..
+        } => {
+            let list: Vec<_> = list
+                .iter()
+                .map(|x| ReturnSuccess::value(x.clone()))
+                .collect();
+
+            futures::stream::iter(list).to_output_stream()
+        }
+        x => OutputStream::one(ReturnSuccess::value(x)),
+    })
+}

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

@@ -0,0 +1,51 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+use std::path::PathBuf;
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+pub struct LoadArgs {
+    load: Tagged<PathBuf>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config load"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config load").required(
+            "load",
+            SyntaxShape::FilePath,
+            "Path to load the config from",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Loads the config from the path given"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set(args).await
+    }
+}
+
+pub async fn set(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let name_span = args.call_info.name_tag.clone();
+    let (LoadArgs { load }, _) = args.process().await?;
+
+    let configuration = load.item().clone();
+
+    let result = nu_data::config::read(name_span, &Some(configuration))?;
+
+    Ok(futures::stream::iter(vec![ReturnSuccess::value(
+        UntaggedValue::Row(result.into()).into_value(name),
+    )])
+    .to_output_stream())
+}

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

@@ -0,0 +1,17 @@
+pub mod clear;
+pub mod command;
+pub mod get;
+pub mod load;
+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 load::SubCommand as ConfigLoad;
+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;

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

@@ -0,0 +1,41 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue};
+
+pub struct SubCommand;
+
+#[async_trait]
+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"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        path(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the path to the current config file",
+            example: "config path",
+            result: None,
+        }]
+    }
+}
+
+pub async fn path(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let path = config::default_path()?;
+
+    Ok(OutputStream::one(ReturnSuccess::value(
+        UntaggedValue::Primitive(Primitive::FilePath(path)).into_value(args.call_info.name_tag),
+    )))
+}

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

@@ -0,0 +1,67 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+pub struct RemoveArgs {
+    remove: Tagged<String>,
+}
+
+#[async_trait]
+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"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        remove(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Remove the startup commands",
+            example: "config remove startup",
+            result: None,
+        }]
+    }
+}
+
+pub async fn remove(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_span = args.call_info.name_tag.clone();
+    let (RemoveArgs { remove }, _) = args.process().await?;
+
+    let mut result = nu_data::config::read(name_span, &None)?;
+
+    let key = remove.to_string();
+
+    if result.contains_key(&key) {
+        result.swap_remove(&key);
+        config::write(&result, &None)?;
+        Ok(futures::stream::iter(vec![ReturnSuccess::value(
+            UntaggedValue::Row(result.into()).into_value(remove.tag()),
+        )])
+        .to_output_stream())
+    } else {
+        Err(ShellError::labeled_error(
+            "Key does not exist in config",
+            "key",
+            remove.tag(),
+        ))
+    }
+}

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

@@ -0,0 +1,89 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+pub struct SetArgs {
+    path: ColumnPath,
+    value: Value,
+}
+
+#[async_trait]
+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"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set(args).await
+    }
+
+    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_bold]; [left $true]]",
+                result: None,
+            },
+            Example {
+                description: "Set nested options",
+                example: "config set color_config.header_color white",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn set(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_tag = args.call_info.name_tag.clone();
+    let (SetArgs { path, mut value }, _) = args.process().await?;
+
+    // NOTE: None because we are not loading a new config file, we just want to read from the
+    // existing config
+    let raw_entries = nu_data::config::read(&name_tag, &None)?;
+    let configuration = UntaggedValue::row(raw_entries).into_value(&name_tag);
+
+    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(&path, value) {
+        Ok(Value {
+            value: UntaggedValue::Row(changes),
+            ..
+        }) => {
+            config::write(&changes.entries, &None)?;
+
+            Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::Row(changes).into_value(name_tag),
+            )))
+        }
+        Ok(_) => Ok(OutputStream::empty()),
+        Err(reason) => Err(reason),
+    }
+}