Include chart binaries. (#2667)

Rename the plugins to be the production names

.azure/azure-pipelines.yml

@@ -1,11 +1,20 @@
 trigger:
-  - master
+  - main
 
 strategy:
   matrix:
     linux-stable:
       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'
@@ -34,29 +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
       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
+  #     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 stable,test-bins
+  - bash: RUSTFLAGS="-D warnings" cargo test --all
     condition: eq(variables['style'], 'unflagged')
     displayName: Run tests
-  - bash: RUSTFLAGS="-D warnings" cargo clippy --all --features=stable -- -D clippy::result_unwrap_used -D clippy::option_unwrap_used
+  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used
     condition: eq(variables['style'], 'unflagged')
     displayName: Check clippy lints
-  - bash: NUSHELL_ENABLE_ALL_FLAGS=1 RUSTFLAGS="-D warnings" cargo test --all --features stable,test-bins
+  - bash: RUSTFLAGS="-D warnings" cargo test --all
     condition: eq(variables['style'], 'canary')
     displayName: Run tests
-  - bash: NUSHELL_ENABLE_ALL_FLAGS=1 RUSTFLAGS="-D warnings" cargo clippy --all --features=stable -- -D clippy::result_unwrap_used -D clippy::option_unwrap_used
+  - 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

@@ -23,8 +23,8 @@ 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)
+ - OS (e.g. Windows):
+ - Nu version (you can use the `version` command to find out): 
+ - Optional features (if any):
 
 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

@@ -4,9 +4,19 @@
 history.txt
 tests/fixtures/nuplayground
 crates/*/target
+
 # Debian/Ubuntu
 debian/.debhelper/
 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

@@ -6,4 +6,9 @@ RUN sudo apt-get update && \
     sudo apt-get install -y \
         libssl-dev \
         libxcb-composite0-dev \
-        pkg-config
+        pkg-config \
+        libpython3.6 \
+        rust-lldb \
+    && sudo rm -rf /var/lib/apt/lists/*
+
+ENV RUST_LLDB=/usr/bin/lldb-8

.gitpod.yml

@@ -1,23 +1,19 @@
 image:
   file: .gitpod.Dockerfile
 tasks:
-  - init: cargo install --path . --force --features=stable
+  - 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,test-bins
+  - 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:
@@ -25,4 +21,5 @@ vscode:
     - 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==
-    - vadimcn.vscode-lldb@1.4.5:lwHCNwtm0kmOBXeQUIPGMQ==
+    - 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,205 +1,119 @@
 [package]
-name = "nu"
-version = "0.10.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"
-homepage = "https://www.nushell.sh"
+description = "A new type of shell"
 documentation = "https://www.nushell.sh/book/"
+edition = "2018"
 exclude = ["images"]
+homepage = "https://www.nushell.sh"
+license = "MIT"
+name = "nu"
+readme = "README.md"
+repository = "https://github.com/nushell/nushell"
+version = "0.21.0"
 
 [workspace]
-
-members = [
-    "crates/nu-macros",
-    "crates/nu-errors",
-    "crates/nu-source",
-    "crates/nu_plugin_average",
-    "crates/nu_plugin_binaryview",
-    "crates/nu_plugin_fetch",
-    "crates/nu_plugin_inc",
-    "crates/nu_plugin_match",
-    "crates/nu_plugin_post",
-    "crates/nu_plugin_ps",
-    "crates/nu_plugin_str",
-    "crates/nu_plugin_sum",
-    "crates/nu_plugin_sys",
-    "crates/nu_plugin_textview",
-    "crates/nu_plugin_tree",
-    "crates/nu-protocol",
-    "crates/nu-plugin",
-    "crates/nu-parser",
-    "crates/nu-value-ext",
-    "crates/nu-build"
-]
+members = ["crates/*/"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-source = { version = "0.10.0", path = "./crates/nu-source" }
-nu-plugin = { version = "0.10.0", path = "./crates/nu-plugin" }
-nu-protocol = { version = "0.10.0", path = "./crates/nu-protocol" }
-nu-errors = { version = "0.10.0", path = "./crates/nu-errors" }
-nu-parser = { version = "0.10.0", path = "./crates/nu-parser" }
-nu-value-ext = { version = "0.10.0", path = "./crates/nu-value-ext" }
-nu_plugin_average = { version = "0.10.0", path = "./crates/nu_plugin_average", optional=true }
-nu_plugin_binaryview = { version = "0.10.0", path = "./crates/nu_plugin_binaryview", optional=true }
-nu_plugin_fetch = { version = "0.10.0", path = "./crates/nu_plugin_fetch", optional=true }
-nu_plugin_inc = { version = "0.10.0", path = "./crates/nu_plugin_inc", optional=true }
-nu_plugin_match = { version = "0.10.0", path = "./crates/nu_plugin_match", optional=true }
-nu_plugin_post = { version = "0.10.0", path = "./crates/nu_plugin_post", optional=true }
-nu_plugin_ps = { version = "0.10.0", path = "./crates/nu_plugin_ps", optional=true }
-nu_plugin_str = { version = "0.10.0", path = "./crates/nu_plugin_str", optional=true }
-nu_plugin_sum = { version = "0.10.0", path = "./crates/nu_plugin_sum", optional=true }
-nu_plugin_sys = { version = "0.10.0", path = "./crates/nu_plugin_sys", optional=true }
-nu_plugin_textview = { version = "0.10.0", path = "./crates/nu_plugin_textview", optional=true }
-nu_plugin_tree = { version = "0.10.0", path = "./crates/nu_plugin_tree", optional=true }
-nu-macros = { version = "0.10.0", path = "./crates/nu-macros" }
+nu-cli = {version = "0.21.0", path = "./crates/nu-cli"}
+nu-data = {version = "0.21.0", path = "./crates/nu-data"}
+nu-errors = {version = "0.21.0", path = "./crates/nu-errors"}
+nu-parser = {version = "0.21.0", path = "./crates/nu-parser"}
+nu-plugin = {version = "0.21.0", path = "./crates/nu-plugin"}
+nu-protocol = {version = "0.21.0", path = "./crates/nu-protocol"}
+nu-source = {version = "0.21.0", path = "./crates/nu-source"}
+nu-value-ext = {version = "0.21.0", path = "./crates/nu-value-ext"}
 
-query_interface = "0.3.5"
-typetag = "0.1.4"
-rustyline = "6.0.0"
-chrono = { version = "0.4.10", features = ["serde"] }
-derive-new = "0.5.8"
-prettytable-rs = "0.8.0"
-itertools = "0.8.2"
-ansi_term = "0.12.1"
-nom = "5.0.1"
-dunce = "1.0.0"
-indexmap = { version = "1.3.2", features = ["serde-1"] }
-byte-unit = "3.0.3"
-base64 = "0.11"
-futures = { version = "0.3", features = ["compat", "io-compat"] }
-async-stream = "0.2"
-futures_codec = "0.4"
-num-traits = "0.2.11"
-term = "0.5.2"
-bytes = "0.4.12"
-log = "0.4.8"
+nu_plugin_binaryview = {version = "0.21.0", path = "./crates/nu_plugin_binaryview", optional = true}
+nu_plugin_chart = {version = "0.21.0", path = "./crates/nu_plugin_chart", optional = true}
+nu_plugin_fetch = {version = "0.21.0", path = "./crates/nu_plugin_fetch", optional = true}
+nu_plugin_from_bson = {version = "0.21.0", path = "./crates/nu_plugin_from_bson", optional = true}
+nu_plugin_from_sqlite = {version = "0.21.0", path = "./crates/nu_plugin_from_sqlite", optional = true}
+nu_plugin_inc = {version = "0.21.0", path = "./crates/nu_plugin_inc", optional = true}
+nu_plugin_match = {version = "0.21.0", path = "./crates/nu_plugin_match", optional = true}
+nu_plugin_post = {version = "0.21.0", path = "./crates/nu_plugin_post", optional = true}
+nu_plugin_ps = {version = "0.21.0", path = "./crates/nu_plugin_ps", optional = true}
+nu_plugin_s3 = {version = "0.21.0", path = "./crates/nu_plugin_s3", optional = true}
+nu_plugin_start = {version = "0.21.0", path = "./crates/nu_plugin_start", optional = true}
+nu_plugin_sys = {version = "0.21.0", path = "./crates/nu_plugin_sys", optional = true}
+nu_plugin_textview = {version = "0.21.0", path = "./crates/nu_plugin_textview", optional = true}
+nu_plugin_to_bson = {version = "0.21.0", path = "./crates/nu_plugin_to_bson", optional = true}
+nu_plugin_to_sqlite = {version = "0.21.0", path = "./crates/nu_plugin_to_sqlite", optional = true}
+nu_plugin_tree = {version = "0.21.0", path = "./crates/nu_plugin_tree", optional = true}
+nu_plugin_xpath = {version = "0.21.0", path = "./crates/nu_plugin_xpath", optional = true}
+
+# Required to bootstrap the main binary
+clap = "2.33.3"
+ctrlc = {version = "3.1.6", optional = true}
+futures = {version = "0.3.5", features = ["compat", "io-compat"]}
+log = "0.4.11"
 pretty_env_logger = "0.4.0"
-serde = { version = "1.0.104", features = ["derive"] }
-bson = { version = "0.14.0", features = ["decimal128"] }
-serde_json = "1.0.47"
-serde-hjson = "0.9.1"
-serde_yaml = "0.8"
-serde_bytes = "0.11.3"
-getset = "0.0.9"
-language-reporting = "0.4.0"
-app_dirs = "1.2.1"
-csv = "1.1"
-toml = "0.5.6"
-clap = "2.33.0"
-git2 = { version = "0.11.0", default_features = false }
-dirs = "2.0.2"
-glob = "0.3.0"
-ctrlc = "3.1.3"
-roxmltree = "0.9.1"
-nom_locate = "1.0.0"
-nom-tracable = "0.4.1"
-unicode-xid = "0.2.0"
-serde_ini = "0.2.0"
-pretty-hex = "0.1.1"
-hex = "0.4"
-tempfile = "3.1.0"
-which = "3.1.0"
-ichwh = "0.3"
-textwrap = {version = "0.11.0", features = ["term_size"]}
-shellexpand = "1.1.1"
-pin-utils = "0.1.0-alpha.4"
-num-bigint = { version = "0.2.6", features = ["serde"] }
-bigdecimal = { version = "0.1.0", features = ["serde"] }
-serde_urlencoded = "0.6.1"
-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.4"
-termcolor = "1.1.0"
-natural = "0.3.0"
-parking_lot = "0.10.0"
-meval = "0.2"
-
-clipboard = {version = "0.5", optional = true }
-ptree = {version = "0.2" }
-starship = { version = "0.35.1", optional = true}
-syntect = {version = "3.2.0", optional = true }
-onig_sys = {version = "=69.1.0", optional = true }
-crossterm = {version = "0.16.0", optional = true}
-url = {version = "2.1.1", optional = true}
-semver = {version = "0.9.0", optional = true}
-filesize = "0.1.0"
-
-[target.'cfg(unix)'.dependencies]
-users = "0.9"
-
-[features]
-# Test executables
-test-bins = []
-
-default = ["sys", "ps", "textview", "inc", "str"]
-stable = ["default", "starship-prompt", "binaryview", "match", "tree", "average", "sum", "post", "fetch", "clipboard"]
-
-# Default
-textview = ["crossterm", "syntect", "onig_sys", "url", "nu_plugin_textview"]
-sys = ["nu_plugin_sys"]
-ps = ["nu_plugin_ps"]
-inc = ["semver", "nu_plugin_inc"]
-str = ["nu_plugin_str"]
-
-# Stable
-average = ["nu_plugin_average"]
-binaryview = ["nu_plugin_binaryview"]
-fetch = ["nu_plugin_fetch"]
-match = ["nu_plugin_match"]
-post = ["nu_plugin_post"]
-starship-prompt = ["starship"]
-sum = ["nu_plugin_sum"]
-trace = ["nu-parser/trace"]
-tree = ["nu_plugin_tree"]
-
-[dependencies.rusqlite]
-version = "0.20.0"
-features = ["bundled", "blob"]
 
 [dev-dependencies]
-pretty_assertions = "0.6.1"
-nu-test-support = { version = "0.10.0", path = "./crates/nu-test-support" }
+dunce = "1.0.1"
+nu-test-support = {version = "0.21.0", path = "./crates/nu-test-support"}
 
 [build-dependencies]
-toml = "0.5.6"
-serde = { version = "1.0.104", features = ["derive"] }
-nu-build = { version = "0.10.0", path = "./crates/nu-build" }
 
-[lib]
-name = "nu"
-doctest = false
-path = "src/lib.rs"
+[features]
+ctrlc-support = ["nu-cli/ctrlc"]
+directories-support = ["nu-cli/directories", "nu-cli/dirs", "nu-data/directories", "nu-data/dirs"]
+git-support = ["nu-cli/git2"]
+ptree-support = ["nu-cli/ptree"]
+rich-benchmark = ["nu-cli/rich-benchmark"]
+rustyline-support = ["nu-cli/rustyline-support"]
+term-support = ["nu-cli/term"]
+uuid-support = ["nu-cli/uuid_crate"]
+which-support = ["nu-cli/ichwh", "nu-cli/which"]
 
-[[bin]]
-name = "fail"
-path = "crates/nu-test-support/src/bins/fail.rs"
-required-features = ["test-bins"]
+default = [
+  "sys",
+  "ps",
+  "textview",
+  "inc",
+  "git-support",
+  "directories-support",
+  "ctrlc-support",
+  "which-support",
+  "ptree-support",
+  "term-support",
+  "uuid-support",
+  "rustyline-support",
+  "match",
+  "post",
+  "fetch",
+  "rich-benchmark",
+]
+extra = ["default", "binaryview", "tree", "clipboard-cli", "trash-support", "start", "bson", "sqlite", "s3", "chart", "xpath"]
+stable = ["default"]
 
-[[bin]]
-name = "chop"
-path = "crates/nu-test-support/src/bins/chop.rs"
-required-features = ["test-bins"]
+wasi = ["inc", "match", "directories-support", "ptree-support", "match", "tree", "rustyline-support"]
 
-[[bin]]
-name = "cococo"
-path = "crates/nu-test-support/src/bins/cococo.rs"
-required-features = ["test-bins"]
+trace = ["nu-parser/trace"]
 
-[[bin]]
-name = "nonu"
-path = "crates/nu-test-support/src/bins/nonu.rs"
-required-features = ["test-bins"]
+# 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"]
+
+# Extra
+binaryview = ["nu_plugin_binaryview"]
+bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
+chart = ["nu_plugin_chart"]
+clipboard-cli = ["nu-cli/clipboard-cli"]
+s3 = ["nu_plugin_s3"]
+sqlite = ["nu_plugin_from_sqlite", "nu_plugin_to_sqlite"]
+start = ["nu_plugin_start"]
+trash-support = ["nu-cli/trash-support"]
+tree = ["nu_plugin_tree"]
+xpath = ["nu_plugin_xpath"]
 
 # Core plugins that ship with `cargo install nu` by default
 # Currently, Cargo limits us to installing only one binary
@@ -219,52 +133,63 @@ name = "nu_plugin_core_ps"
 path = "src/plugins/nu_plugin_core_ps.rs"
 required-features = ["ps"]
 
-[[bin]]
-name = "nu_plugin_core_str"
-path = "src/plugins/nu_plugin_core_str.rs"
-required-features = ["str"]
-
 [[bin]]
 name = "nu_plugin_core_sys"
 path = "src/plugins/nu_plugin_core_sys.rs"
 required-features = ["sys"]
 
-# Stable plugins
 [[bin]]
-name = "nu_plugin_stable_average"
-path = "src/plugins/nu_plugin_stable_average.rs"
-required-features = ["average"]
-
-[[bin]]
-name = "nu_plugin_stable_fetch"
-path = "src/plugins/nu_plugin_stable_fetch.rs"
+name = "nu_plugin_core_fetch"
+path = "src/plugins/nu_plugin_core_fetch.rs"
 required-features = ["fetch"]
 
 [[bin]]
-name = "nu_plugin_stable_binaryview"
-path = "src/plugins/nu_plugin_stable_binaryview.rs"
-required-features = ["binaryview"]
-
-[[bin]]
-name = "nu_plugin_stable_match"
-path = "src/plugins/nu_plugin_stable_match.rs"
+name = "nu_plugin_core_match"
+path = "src/plugins/nu_plugin_core_match.rs"
 required-features = ["match"]
 
 [[bin]]
-name = "nu_plugin_stable_post"
-path = "src/plugins/nu_plugin_stable_post.rs"
+name = "nu_plugin_core_post"
+path = "src/plugins/nu_plugin_core_post.rs"
 required-features = ["post"]
 
-[[bin]]
-name = "nu_plugin_stable_sum"
-path = "src/plugins/nu_plugin_stable_sum.rs"
-required-features = ["sum"]
+# Extra plugins
 
 [[bin]]
-name = "nu_plugin_stable_tree"
-path = "src/plugins/nu_plugin_stable_tree.rs"
+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"]
+
 # Main nu binary
 [[bin]]
 name = "nu"

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,27 +1,36 @@
+# README
+
 [![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/nushell/nushell)
 [![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)
 [![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)
 
-
-# Nu Shell
+## Nu Shell
 
 A new type of shell.
 
 ![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://www.nushell.sh/book/) 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://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.
+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.
 
@@ -31,44 +40,54 @@ 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://www.nushell.sh/book/en/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.41 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`
+  * 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`
+  * 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 build Nu yourself with all the bells and whistles (be sure to have installed the [dependencies](https://www.nushell.sh/book/en/installation.html#dependencies) for your platform), once you have checked out this repo with git:
 
-```
-cargo build --workspace --features=stable
+```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`
@@ -78,153 +97,176 @@ 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 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.
+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
-───┴───────┴─────────────────┴──────────┴──────────
+```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.9.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.15.1
+───────────────┴────────────────────────────────────
 ```
 
 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.9.0
+```shell
+> open Cargo.toml | get package.version | echo $it
+0.15.1
 ```
 
 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/en/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                   |
-| completion_mode | "circular" or "list" | changes completion type to "circular" (default) or "list" 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 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.
 
@@ -238,11 +280,39 @@ Nu adheres closely to a set of goals that make up its design philosophy. As feat
 
 * Finally, Nu views data functionally. Rather than using mutation, pipelines act as a means to load, change, and save data without mutable state.
 
-# Commands
+## Commands
 
-You can find a list of Nu commands, complete with documentation, in [quick command references](https://www.nushell.sh/documentation.html#quick-command-references). 
+You can find a list of Nu commands, complete with documentation, in [quick command references](https://www.nushell.sh/documentation.html#quick-command-references).
 
-# License
+## Progress
 
-The project is made available under the MIT license. See "LICENSE" for more information.
+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:
 
+| 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
+
+## Current Roadmap
+
+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.
+
+## License
+
+The project is made available under the MIT license. See the `LICENSE` file for more information.

TODO.md

@@ -1,60 +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
-
-Combine atomic and atomic_parse in parser
-
-at_end_possible_ws needs to be comment and separator sensitive
-
-Eliminate unnecessary `nodes` parser
-
-#[derive(HasSpan)]
-
-Figure out a solution for the duplication in stuff like NumberShape vs. NumberExpressionShape
-
-use `struct Expander` from signature.rs

build.rs

@@ -1,3 +0,0 @@
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    nu_build::build()
-}

crates/nu-build/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "nu-build"
-version = "0.10.0"
-authors = ["Yehuda Katz <wycats@gmail.com>", "Jonathan Turner <jonathan.d.turner@gmail.com>", "Andrés N. Robalino <andres@androbtech.com>"]
-edition = "2018"
-description = "Core build system for nushell"
-license = "MIT"
-
-[lib]
-doctest = false
-
-[dependencies]
-serde = { version = "1.0.103", features = ["derive"] }
-lazy_static = "1.4.0"
-serde_json = "1.0.44"
-toml = "0.5.5"

crates/nu-build/src/lib.rs

@@ -1,80 +0,0 @@
-use lazy_static::lazy_static;
-use serde::Deserialize;
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::env;
-use std::path::{Path, PathBuf};
-use std::sync::Mutex;
-
-lazy_static! {
-    static ref WORKSPACES: Mutex<BTreeMap<String, &'static Path>> = Mutex::new(BTreeMap::new());
-}
-
-// got from https://github.com/mitsuhiko/insta/blob/b113499249584cb650150d2d01ed96ee66db6b30/src/runtime.rs#L67-L88
-
-fn get_cargo_workspace(manifest_dir: &str) -> Result<Option<&Path>, Box<dyn std::error::Error>> {
-    let mut workspaces = WORKSPACES.lock()?;
-    if let Some(rv) = workspaces.get(manifest_dir) {
-        Ok(Some(rv))
-    } else {
-        #[derive(Deserialize)]
-        struct Manifest {
-            workspace_root: String,
-        }
-        let output = std::process::Command::new(env!("CARGO"))
-            .arg("metadata")
-            .arg("--format-version=1")
-            .current_dir(manifest_dir)
-            .output()?;
-        let manifest: Manifest = serde_json::from_slice(&output.stdout)?;
-        let path = Box::leak(Box::new(PathBuf::from(manifest.workspace_root)));
-        workspaces.insert(manifest_dir.to_string(), path.as_path());
-        Ok(workspaces.get(manifest_dir).cloned())
-    }
-}
-
-#[derive(Deserialize)]
-struct Feature {
-    #[allow(unused)]
-    description: String,
-    enabled: bool,
-}
-
-pub fn build() -> Result<(), Box<dyn std::error::Error>> {
-    let input = env::var("CARGO_MANIFEST_DIR")?;
-
-    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 workspace = match get_cargo_workspace(&input)? {
-        // If the crate is being downloaded from crates.io, it won't have a workspace root, and that's ok
-        None => return Ok(()),
-        Some(workspace) => workspace,
-    };
-
-    let path = Path::new(&workspace).join("features.toml");
-
-    // If the crate is being downloaded from crates.io, it won't have a features.toml, and that's ok
-    if !path.exists() {
-        return Ok(());
-    }
-
-    let toml: HashMap<String, Feature> = toml::from_str(&std::fs::read_to_string(path)?)?;
-
-    for (key, value) in toml.iter() {
-        if value.enabled || all_on || flags.contains(key) {
-            println!("cargo:rustc-cfg={}", key);
-        }
-    }
-
-    Ok(())
-}

crates/nu-cli/Cargo.toml

@@ -0,0 +1,129 @@
+[package]
+authors = ["The Nu Project Contributors"]
+description = "CLI for nushell"
+edition = "2018"
+license = "MIT"
+name = "nu-cli"
+version = "0.21.0"
+
+[lib]
+doctest = false
+
+[dependencies]
+nu-data = {version = "0.21.0", path = "../nu-data"}
+nu-errors = {version = "0.21.0", path = "../nu-errors"}
+nu-parser = {version = "0.21.0", path = "../nu-parser"}
+nu-plugin = {version = "0.21.0", path = "../nu-plugin"}
+nu-protocol = {version = "0.21.0", path = "../nu-protocol"}
+nu-source = {version = "0.21.0", path = "../nu-source"}
+nu-table = {version = "0.21.0", path = "../nu-table"}
+nu-test-support = {version = "0.21.0", path = "../nu-test-support"}
+nu-value-ext = {version = "0.21.0", path = "../nu-value-ext"}
+
+ansi_term = "0.12.1"
+async-recursion = "0.3.1"
+async-trait = "0.1.40"
+base64 = "0.12.3"
+bigdecimal = {version = "0.2.0", features = ["serde"]}
+byte-unit = "4.0.9"
+bytes = "0.5.6"
+calamine = "0.16.1"
+chrono = {version = "0.4.15", features = ["serde"]}
+clap = "2.33.3"
+codespan-reporting = "0.9.5"
+csv = "1.1.3"
+ctrlc = {version = "3.1.6", optional = true}
+derive-new = "0.5.8"
+directories = {version = "3.0.1", optional = true}
+dirs = {version = "3.0.1", optional = true}
+dtparse = "1.2.0"
+dunce = "1.0.1"
+eml-parser = "0.1.0"
+filesize = "0.2.0"
+fs_extra = "1.2.0"
+futures = {version = "0.3.5", features = ["compat", "io-compat"]}
+futures-util = "0.3.5"
+futures_codec = "0.4.1"
+getset = "0.1.1"
+git2 = {version = "0.13.11", default_features = false, optional = true}
+glob = "0.3.0"
+heim = {version = "0.1.0-beta.3", optional = true}
+htmlescape = "0.3.1"
+ical = "0.6.0"
+ichwh = {version = "0.3.4", optional = true}
+indexmap = {version = "1.6.0", features = ["serde-1"]}
+itertools = "0.9.0"
+log = "0.4.11"
+meval = "0.2.0"
+num-bigint = {version = "0.3.0", features = ["serde"]}
+num-format = {version = "0.4.0", features = ["with-num-bigint"]}
+num-traits = "0.2.12"
+parking_lot = "0.11.0"
+pin-utils = "0.1.0"
+pretty-hex = "0.2.0"
+ptree = {version = "0.3.0", optional = true}
+query_interface = "0.3.5"
+quick-xml = "0.18.1"
+rand = "0.7.3"
+regex = "1.3.9"
+roxmltree = "0.13.0"
+rust-embed = "5.6.0"
+rustyline = {version = "6.3.0", optional = true}
+serde = {version = "1.0.115", features = ["derive"]}
+serde-hjson = "0.9.1"
+serde_bytes = "0.11.5"
+serde_ini = "0.2.0"
+serde_json = "1.0.57"
+serde_urlencoded = "0.7.0"
+serde_yaml = "0.8.13"
+sha2 = "0.9.1"
+shellexpand = "2.0.0"
+strip-ansi-escapes = "0.1.0"
+sxd-document = "0.3.2"
+sxd-xpath = "0.4.2"
+tempfile = "3.1.0"
+term = {version = "0.6.1", optional = true}
+term_size = "0.3.2"
+termcolor = "1.1.0"
+toml = "0.5.6"
+unicode-segmentation = "1.6.0"
+uom = {version = "0.28.0", features = ["f64", "try-from"]}
+uuid_crate = {package = "uuid", version = "0.8.1", features = ["v4"], optional = true}
+which = {version = "4.0.2", optional = true}
+zip = {version = "0.5.7", optional = true}
+
+Inflector = "0.11"
+clipboard = {version = "0.5.0", optional = true}
+encoding_rs = "0.8.24"
+rayon = "1.4.0"
+trash = {version = "1.1.1", optional = true}
+url = "2.1.1"
+
+[target.'cfg(unix)'.dependencies]
+umask = "1.0.0"
+users = "0.10.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.0"
+
+[build-dependencies]
+git2 = {version = "0.13.11", optional = true}
+
+[dev-dependencies]
+quickcheck = "0.9.2"
+quickcheck_macros = "0.9.1"
+
+[features]
+clipboard-cli = ["clipboard"]
+rich-benchmark = ["heim"]
+rustyline-support = ["rustyline"]
+stable = []
+trash-support = ["trash"]

crates/nu-cli/build.rs

@@ -0,0 +1,36 @@
+use std::path::Path;
+use std::{env, fs, io};
+
+fn main() -> Result<(), io::Error> {
+    let out_dir = env::var_os("OUT_DIR").expect(
+    "\
+        OUT_DIR environment variable not found. \
+        OUT_DIR is guaranteed to to exist in a build script by cargo - see \
+        https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-build-scripts\
+    ");
+
+    let latest_commit_hash = latest_commit_hash(env::current_dir()?).unwrap_or_default();
+
+    let commit_hash_path = Path::new(&out_dir).join("git_commit_hash");
+    fs::write(commit_hash_path, latest_commit_hash)?;
+
+    Ok(())
+}
+
+#[allow(unused_variables)]
+fn latest_commit_hash<P: AsRef<Path>>(dir: P) -> Result<String, Box<dyn std::error::Error>> {
+    #[cfg(feature = "git2")]
+    {
+        use git2::Repository;
+        let dir = dir.as_ref();
+        Ok(Repository::discover(dir)?
+            .head()?
+            .peel_to_commit()?
+            .id()
+            .to_string())
+    }
+    #[cfg(not(feature = "git2"))]
+    {
+        Ok(String::new())
+    }
+}

crates/nu-cli/src/command_registry.rs

@@ -0,0 +1,64 @@
+use crate::commands::Command;
+use indexmap::IndexMap;
+use nu_errors::ShellError;
+use nu_parser::SignatureRegistry;
+use nu_protocol::Signature;
+use parking_lot::Mutex;
+use std::sync::Arc;
+
+#[derive(Debug, Clone, Default)]
+pub struct CommandRegistry {
+    registry: Arc<Mutex<IndexMap<String, Command>>>,
+}
+
+impl SignatureRegistry for CommandRegistry {
+    fn has(&self, name: &str) -> bool {
+        let registry = self.registry.lock();
+        registry.contains_key(name)
+    }
+    fn get(&self, name: &str) -> Option<Signature> {
+        let registry = self.registry.lock();
+        registry.get(name).map(|command| command.signature())
+    }
+    fn clone_box(&self) -> Box<dyn SignatureRegistry> {
+        Box::new(self.clone())
+    }
+}
+
+impl CommandRegistry {
+    pub fn new() -> CommandRegistry {
+        CommandRegistry {
+            registry: Arc::new(Mutex::new(IndexMap::default())),
+        }
+    }
+}
+
+impl CommandRegistry {
+    pub fn get_command(&self, name: &str) -> Option<Command> {
+        let registry = self.registry.lock();
+
+        registry.get(name).cloned()
+    }
+
+    pub fn expect_command(&self, name: &str) -> Result<Command, ShellError> {
+        self.get_command(name).ok_or_else(|| {
+            ShellError::untagged_runtime_error(format!("Could not load command: {}", name))
+        })
+    }
+
+    pub fn has(&self, name: &str) -> bool {
+        let registry = self.registry.lock();
+
+        registry.contains_key(name)
+    }
+
+    pub fn insert(&mut self, name: impl Into<String>, command: Command) {
+        let mut registry = self.registry.lock();
+        registry.insert(name.into(), command);
+    }
+
+    pub fn names(&self) -> Vec<String> {
+        let registry = self.registry.lock();
+        registry.keys().cloned().collect()
+    }
+}

crates/nu-cli/src/commands.rs

@@ -0,0 +1,308 @@
+#[macro_use]
+pub(crate) mod macros;
+
+mod from_delimited_data;
+mod to_delimited_data;
+
+pub(crate) mod alias;
+pub(crate) mod ansi;
+pub(crate) mod append;
+pub(crate) mod args;
+pub(crate) 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(crate) 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 default;
+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 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 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 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 run_alias;
+pub(crate) mod run_external;
+pub(crate) mod save;
+pub(crate) mod select;
+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 split;
+pub(crate) mod split_by;
+pub(crate) mod str_;
+pub(crate) mod table;
+pub(crate) mod tags;
+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 command::{
+    whole_stream_command, Command, Example, UnevaluatedCallInfo, WholeStreamCommand,
+};
+
+pub(crate) use alias::Alias;
+pub(crate) use ansi::Ansi;
+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, DateNow, DateUTC};
+pub(crate) use debug::Debug;
+pub(crate) use default::Default;
+pub(crate) use describe::Describe;
+pub(crate) use do_::Do;
+pub(crate) use drop::Drop;
+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 format::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::Get;
+pub(crate) use group_by::Command as GroupBy;
+pub(crate) use group_by_date::GroupByDate;
+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 lines::Lines;
+pub(crate) use ls::Ls;
+pub(crate) use math::{
+    Math, MathAverage, MathEval, MathMaximum, MathMedian, MathMinimum, MathMode, MathProduct,
+    MathStddev, MathSummation, MathVariance,
+};
+pub(crate) use merge::Merge;
+pub(crate) use mkdir::Mkdir;
+pub(crate) use move_::{Move, MoveColumn, 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,
+    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, 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 run_external::RunExternalCommand;
+pub(crate) use save::Save;
+pub(crate) use select::Select;
+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 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, StrSet, StrSnakeCase, StrStartsWith, StrSubstring,
+    StrToDatetime, StrToDecimal, StrToInteger, StrTrim, StrTrimLeft, StrTrimRight, StrUpcase,
+};
+pub(crate) use table::Table;
+pub(crate) use tags::Tags;
+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::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::commands::whole_stream_command;
+    use crate::examples::{test_anchors, test_examples};
+    use nu_errors::ShellError;
+
+    fn commands() -> Vec<Command> {
+        vec![
+            whole_stream_command(Append),
+            whole_stream_command(GroupBy),
+            whole_stream_command(Insert),
+            whole_stream_command(Update),
+            whole_stream_command(Empty),
+        ]
+    }
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        for cmd in commands() {
+            test_examples(cmd)?;
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn tracks_metadata() -> Result<(), ShellError> {
+        for cmd in commands() {
+            test_anchors(cmd)?;
+        }
+
+        Ok(())
+    }
+}

crates/nu-cli/src/commands/alias.rs

@@ -0,0 +1,351 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_data::config;
+use nu_errors::ShellError;
+use nu_parser::SignatureRegistry;
+use nu_protocol::hir::{ClassifiedCommand, Expression, NamedValue, SpannedExpression, Variable};
+use nu_protocol::{
+    hir::Block, CommandAction, NamedType, PositionalType, ReturnSuccess, Signature, SyntaxShape,
+    UntaggedValue, Value,
+};
+use nu_source::Tagged;
+use std::collections::HashMap;
+
+pub struct Alias;
+
+#[derive(Deserialize)]
+pub struct AliasArgs {
+    pub name: Tagged<String>,
+    pub args: Vec<Value>,
+    pub block: Block,
+    pub infer: Option<bool>,
+    pub save: Option<bool>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Alias {
+    fn name(&self) -> &str {
+        "alias"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("alias")
+            .required("name", SyntaxShape::String, "the name of the alias")
+            .required("args", SyntaxShape::Table, "the arguments to the alias")
+            .required(
+                "block",
+                SyntaxShape::Block,
+                "the block to run as the body of the alias",
+            )
+            .switch("infer", "infer argument types (experimental)", Some('i'))
+            .switch("save", "save the alias to your config", Some('s'))
+    }
+
+    fn usage(&self) -> &str {
+        "Define a shortcut for another command."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        alias(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "An alias without parameters",
+                example: "alias say-hi [] { echo 'Hello!' }",
+                result: None,
+            },
+            Example {
+                description: "An alias with a single parameter",
+                example: "alias l [x] { ls $x }",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn alias(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let mut raw_input = args.raw_input.clone();
+    let (
+        AliasArgs {
+            name,
+            args: list,
+            block,
+            infer,
+            save,
+        },
+        _ctx,
+    ) = args.process(&registry).await?;
+    let mut processed_args: Vec<String> = vec![];
+
+    if let Some(true) = save {
+        let mut result = nu_data::config::read(name.clone().tag, &None)?;
+
+        // process the alias to remove the --save flag
+        let left_brace = raw_input.find('{').unwrap_or(0);
+        let right_brace = raw_input.rfind('}').unwrap_or_else(|| raw_input.len());
+        let left = raw_input[..left_brace]
+            .replace("--save", "") // TODO using regex (or reconstruct string from AST?)
+            .replace("-si", "-i")
+            .replace("-s ", "")
+            .replace("-is", "-i");
+        let right = raw_input[right_brace..]
+            .replace("--save", "")
+            .replace("-si", "-i")
+            .replace("-s ", "")
+            .replace("-is", "-i");
+        raw_input = format!("{}{}{}", left, &raw_input[left_brace..right_brace], right);
+
+        // create a value from raw_input alias
+        let alias: Value = raw_input.trim().to_string().into();
+        let alias_start = raw_input.find('[').unwrap_or(0); // used to check if the same alias already exists
+
+        // add to startup if alias doesn't exist and replce if it does
+        match result.get_mut("startup") {
+            Some(startup) => {
+                if let UntaggedValue::Table(ref mut commands) = startup.value {
+                    if let Some(command) = commands.iter_mut().find(|command| {
+                        let cmd_str = command.as_string().unwrap_or_default();
+                        cmd_str.starts_with(&raw_input[..alias_start])
+                    }) {
+                        *command = alias;
+                    } else {
+                        commands.push(alias);
+                    }
+                }
+            }
+            None => {
+                let table = UntaggedValue::table(&[alias]);
+                result.insert("startup".to_string(), table.into_value(Tag::default()));
+            }
+        }
+        config::write(&result, &None)?;
+    }
+
+    for item in list.iter() {
+        if let Ok(string) = item.as_string() {
+            processed_args.push(format!("${}", string));
+        } else {
+            return Err(ShellError::labeled_error(
+                "Expected a string",
+                "expected a string",
+                item.tag(),
+            ));
+        }
+    }
+
+    if let Some(true) = infer {
+        Ok(OutputStream::one(ReturnSuccess::action(
+            CommandAction::AddAlias(
+                name.to_string(),
+                to_arg_shapes(processed_args, &block, &registry)?,
+                block,
+            ),
+        )))
+    } else {
+        Ok(OutputStream::one(ReturnSuccess::action(
+            CommandAction::AddAlias(
+                name.to_string(),
+                processed_args
+                    .into_iter()
+                    .map(|arg| (arg, SyntaxShape::Any))
+                    .collect(),
+                block,
+            ),
+        )))
+    }
+}
+
+fn to_arg_shapes(
+    args: Vec<String>,
+    block: &Block,
+    registry: &CommandRegistry,
+) -> Result<Vec<(String, SyntaxShape)>, ShellError> {
+    match find_block_shapes(block, registry) {
+        Ok(found) => Ok(args
+            .iter()
+            .map(|arg| {
+                (
+                    arg.clone(),
+                    match found.get(arg) {
+                        None | Some((_, None)) => SyntaxShape::Any,
+                        Some((_, Some(shape))) => *shape,
+                    },
+                )
+            })
+            .collect()),
+        Err(err) => Err(err),
+    }
+}
+
+type ShapeMap = HashMap<String, (Span, Option<SyntaxShape>)>;
+
+fn check_insert(
+    existing: &mut ShapeMap,
+    to_add: (String, (Span, Option<SyntaxShape>)),
+) -> Result<(), ShellError> {
+    match (to_add.1).1 {
+        None => match existing.get(&to_add.0) {
+            None => {
+                existing.insert(to_add.0, to_add.1);
+                Ok(())
+            }
+            Some(_) => Ok(()),
+        },
+        Some(new) => match existing.insert(to_add.0.clone(), ((to_add.1).0, Some(new))) {
+            None => Ok(()),
+            Some(exist) => match exist.1 {
+                None => Ok(()),
+                Some(shape) => match shape {
+                    SyntaxShape::Any => Ok(()),
+                    shape if shape == new => Ok(()),
+                    _ => Err(ShellError::labeled_error_with_secondary(
+                        "Type conflict in alias variable use",
+                        format!("{:?}", new),
+                        (to_add.1).0,
+                        format!("{:?}", shape),
+                        exist.0,
+                    )),
+                },
+            },
+        },
+    }
+}
+
+fn check_merge(existing: &mut ShapeMap, new: &ShapeMap) -> Result<(), ShellError> {
+    for (k, v) in new.iter() {
+        check_insert(existing, (k.clone(), *v))?;
+    }
+
+    Ok(())
+}
+
+fn find_expr_shapes(
+    spanned_expr: &SpannedExpression,
+    registry: &CommandRegistry,
+) -> Result<ShapeMap, ShellError> {
+    match &spanned_expr.expr {
+        // TODO range will need similar if/when invocations can be parsed within range expression
+        Expression::Binary(bin) => find_expr_shapes(&bin.left, registry).and_then(|mut left| {
+            find_expr_shapes(&bin.right, registry)
+                .and_then(|right| check_merge(&mut left, &right).map(|()| left))
+        }),
+        Expression::Block(b) => find_block_shapes(&b, registry),
+        Expression::Path(path) => match &path.head.expr {
+            Expression::Invocation(b) => find_block_shapes(&b, registry),
+            Expression::Variable(Variable::Other(var, _)) => {
+                let mut result = HashMap::new();
+                result.insert(var.to_string(), (spanned_expr.span, None));
+                Ok(result)
+            }
+            _ => Ok(HashMap::new()),
+        },
+        _ => Ok(HashMap::new()),
+    }
+}
+
+fn find_block_shapes(block: &Block, registry: &CommandRegistry) -> Result<ShapeMap, ShellError> {
+    let apply_shape = |found: ShapeMap, sig_shape: SyntaxShape| -> ShapeMap {
+        found
+            .iter()
+            .map(|(v, sh)| match sh.1 {
+                None => (v.clone(), (sh.0, Some(sig_shape))),
+                Some(shape) => (v.clone(), (sh.0, Some(shape))),
+            })
+            .collect()
+    };
+
+    let mut arg_shapes = HashMap::new();
+    for pipeline in &block.block {
+        for classified in &pipeline.list {
+            match classified {
+                ClassifiedCommand::Expr(spanned_expr) => {
+                    let found = find_expr_shapes(&spanned_expr, registry)?;
+                    check_merge(&mut arg_shapes, &found)?
+                }
+                ClassifiedCommand::Internal(internal) => {
+                    if let Some(signature) = registry.get(&internal.name) {
+                        if let Some(positional) = &internal.args.positional {
+                            for (i, spanned_expr) in positional.iter().enumerate() {
+                                let found = find_expr_shapes(&spanned_expr, registry)?;
+                                if i >= signature.positional.len() {
+                                    if let Some((sig_shape, _)) = &signature.rest_positional {
+                                        check_merge(
+                                            &mut arg_shapes,
+                                            &apply_shape(found, *sig_shape),
+                                        )?;
+                                    } else {
+                                        unreachable!("should have error'd in parsing");
+                                    }
+                                } else {
+                                    let (pos_type, _) = &signature.positional[i];
+                                    match pos_type {
+                                        // TODO pass on mandatory/optional?
+                                        PositionalType::Mandatory(_, sig_shape)
+                                        | PositionalType::Optional(_, sig_shape) => {
+                                            check_merge(
+                                                &mut arg_shapes,
+                                                &apply_shape(found, *sig_shape),
+                                            )?;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        if let Some(named) = &internal.args.named {
+                            for (name, val) in named.iter() {
+                                if let NamedValue::Value(_, spanned_expr) = val {
+                                    let found = find_expr_shapes(&spanned_expr, registry)?;
+                                    match signature.named.get(name) {
+                                        None => {
+                                            unreachable!("should have error'd in parsing");
+                                        }
+                                        Some((named_type, _)) => {
+                                            if let NamedType::Mandatory(_, sig_shape)
+                                            | NamedType::Optional(_, sig_shape) = named_type
+                                            {
+                                                check_merge(
+                                                    &mut arg_shapes,
+                                                    &apply_shape(found, *sig_shape),
+                                                )?;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        unreachable!("registry has lost name it provided");
+                    }
+                }
+                ClassifiedCommand::Dynamic(_) | ClassifiedCommand::Error(_) => (),
+            }
+        }
+    }
+
+    Ok(arg_shapes)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Alias;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Alias {})?)
+    }
+}

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

@@ -0,0 +1,146 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use ansi_term::Color;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct Ansi;
+
+#[derive(Deserialize)]
+struct AnsiArgs {
+    color: Value,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Ansi {
+    fn name(&self) -> &str {
+        "ansi"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("ansi").required(
+            "color",
+            SyntaxShape::Any,
+            "the name of the color to use or 'reset' to reset the color",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Output ANSI codes to change color"
+    }
+
+    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",
+                )]),
+            },
+        ]
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let (AnsiArgs { color }, _) = args.process(&registry).await?;
+
+        let color_string = color.as_string()?;
+
+        let ansi_code = str_to_ansi_color(color_string);
+
+        if let Some(output) = ansi_code {
+            Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(color.tag()),
+            )))
+        } else {
+            Err(ShellError::labeled_error(
+                "Unknown color",
+                "unknown color",
+                color.tag(),
+            ))
+        }
+    }
+}
+
+pub fn str_to_ansi_color(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()),
+        "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()),
+        "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()),
+        "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()),
+        "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()),
+        "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()),
+        "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()),
+        "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()),
+        "reset" => Some("\x1b[0m".to_owned()),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Ansi;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Ansi {})?)
+    }
+}

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

@@ -0,0 +1,63 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+#[derive(Deserialize)]
+struct Arguments {
+    row: 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 the given row to the table"
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let (Arguments { mut row }, input) = args.process(registry).await?;
+
+        let input: Vec<Value> = input.collect().await;
+
+        if let Some(first) = input.get(0) {
+            row.tag = first.tag();
+        }
+
+        Ok(
+            futures::stream::iter(input.into_iter().chain(vec![row]).map(ReturnSuccess::value))
+                .to_output_stream(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Add something to the end of a list or 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(),
+            ]),
+        }]
+    }
+}

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

@@ -0,0 +1,92 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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::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: &PathBuf, 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 {
+        // "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#"Manage directory specific environment variables and scripts. 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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let registry = registry.clone();
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(crate::commands::help::get_help(&Autoenv, &registry))
+                .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-cli/src/commands/autoenv_trust.rs

@@ -0,0 +1,83 @@
+use super::autoenv::read_trusted;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+
+        let file_to_trust = match args.call_info.evaluate(registry).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-cli/src/commands/autoenv_untrust.rs

@@ -0,0 +1,107 @@
+use super::autoenv::Trusted;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let file_to_untrust = match args.call_info.evaluate(registry).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-cli/src/commands/autoview/command.rs

@@ -0,0 +1,337 @@
+use crate::commands::autoview::options::{ConfigExtensions, NuConfig as AutoViewConfiguration};
+use crate::commands::{UnevaluatedCallInfo, WholeStreamCommand};
+use crate::prelude::*;
+use crate::primitive::get_color_config;
+use nu_data::value::format_leaf;
+use nu_errors::ShellError;
+use nu_protocol::hir::{self, Expression, ExternalRedirection, Literal, SpannedExpression};
+use nu_protocol::{Primitive, Scope, 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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        autoview(RunnableContext {
+            input: args.input,
+            registry: registry.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,
+            raw_input: args.raw_input,
+        })
+        .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 registry: CommandRegistry,
+    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,
+            registry: context.registry,
+            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, &context.registry).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, &context.registry).await?;
+                            result.collect::<Vec<_>>().await;
+                        } else {
+                            out!("{}", s);
+                        }
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::String(s)),
+                        ..
+                    } => {
+                        out!("{}", s);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Line(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, &context.registry).await?;
+                            result.collect::<Vec<_>>().await;
+                        } else {
+                            out!("{}\n", s);
+                        }
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Line(s)),
+                        ..
+                    } => {
+                        out!("{}\n", s);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Path(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::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, &context.registry).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(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());
+
+                        nu_table::draw_table(&table, term_width, &color_hm);
+                    }
+
+                    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, &context.registry).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::create(),
+        },
+    }
+}
+
+#[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;
+
+        Ok(test_examples(Command {})?)
+    }
+}

crates/nu-cli/src/commands/autoview/mod.rs

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

crates/nu-cli/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-cli/src/commands/benchmark.rs

@@ -0,0 +1,212 @@
+use crate::commands::classified::block::run_block;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+#[cfg(feature = "rich-benchmark")]
+use heim::cpu::time;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::{Block, ClassifiedCommand, Commands, InternalCommand},
+    Dictionary, Scope, 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: Block,
+    passthrough: Option<Block>,
+}
+
+#[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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        benchmark(args, registry).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,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+
+    let tag = raw_args.call_info.args.span;
+    let mut context = EvaluationContext::from_raw(&raw_args, &registry);
+    let scope = raw_args.call_info.scope.clone();
+    let (BenchmarkArgs { block, passthrough }, input) = raw_args.process(&registry).await?;
+
+    let env = scope.env();
+    let name = generate_free_name(&env);
+    let mut env = IndexMap::new();
+    env.insert(name, generate_random_env_value());
+    let scope = Scope::append_env(scope, env);
+
+    let start_time = Instant::now();
+
+    #[cfg(feature = "rich-benchmark")]
+    let start = time().await;
+
+    let result = run_block(&block, &mut context, input, scope.clone()).await;
+    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, scope).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, scope).await
+    } else {
+        Err(ShellError::untagged_runtime_error(
+            "Could not retreive CPU time",
+        ))
+    }
+}
+
+async fn benchmark_output<T, Output>(
+    indexmap: IndexMap<String, BigInt>,
+    block_output: Output,
+    passthrough: Option<Block>,
+    tag: T,
+    context: &mut EvaluationContext,
+    scope: Arc<Scope>,
+) -> 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);
+
+        let _ = run_block(&time_block, context, benchmark_output, scope).await?;
+        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() {
+        block.push({
+            let mut commands = Commands::new(block.span);
+            commands.push(ClassifiedCommand::Internal(InternalCommand::new(
+                "autoview".to_string(),
+                block.span,
+                block.span,
+            )));
+            commands
+        });
+    }
+    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-cli/src/commands/build_string.rs

@@ -0,0 +1,56 @@
+use crate::prelude::*;
+use nu_errors::ShellError;
+
+use crate::commands::WholeStreamCommand;
+use nu_data::value::format_leaf;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let (BuildStringArgs { rest }, _) = args.process(&registry).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-cli/src/commands/cal.rs

@@ -0,0 +1,350 @@
+use crate::commands::{command::EvaluatedWholeStreamCommandArgs, WholeStreamCommand};
+use crate::prelude::*;
+use chrono::{Datelike, Local, NaiveDate};
+use indexmap::IndexMap;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        cal(args, registry).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,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let args = args.evaluate_once(&registry).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;
+
+        Ok(test_examples(Cal {})?)
+    }
+}

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

@@ -0,0 +1,83 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+
+use std::path::PathBuf;
+
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape};
+use nu_source::Tagged;
+
+#[derive(Deserialize)]
+pub struct CdArgs {
+    pub(crate) path: Option<Tagged<PathBuf>>,
+}
+
+pub struct Cd;
+
+#[async_trait]
+impl WholeStreamCommand for Cd {
+    fn name(&self) -> &str {
+        "cd"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("cd").optional(
+            "directory",
+            SyntaxShape::Path,
+            "the directory to change to",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Change to a new path."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let name = args.call_info.name_tag.clone();
+        let shell_manager = args.shell_manager.clone();
+        let (args, _): (CdArgs, _) = args.process(&registry).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;
+
+        Ok(test_examples(Cd {})?)
+    }
+}

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

@@ -0,0 +1,141 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Char {
+    fn name(&self) -> &str {
+        "char"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("ansi").required(
+            "character",
+            SyntaxShape::Any,
+            "the name of the character to output",
+        )
+    }
+
+    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(),
+                ]),
+            },
+        ]
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let (CharArgs { name }, _) = args.process(&registry).await?;
+
+        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(
+                "Unknown character",
+                "unknown character",
+                name.tag(),
+            ))
+        }
+    }
+}
+
+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)
+        "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" => Some("\x1b[33;1m\u{2600}\x1b[0m".to_string()), // Yellow Bold ☀
+        "moon" => Some("\x1b[36m\u{263d}\x1b[0m".to_string()),  // Cyan ☽
+        "clouds" => Some("\x1b[37;1m\u{2601}\x1b[0m".to_string()), // White Bold ☁
+        "rain" => Some("\x1b[37;1m\u{2614}\x1b[0m".to_string()), // White Bold ☔
+        "fog" => Some("\x1b[37;1m\u{2592}\x1b[0m".to_string()), // White Bold ▒
+        "mist" => Some("\x1b[34m\u{2591}\x1b[0m".to_string()),  // Blue ░
+        "haze" => Some("\x1b[33m\u{2591}\x1b[0m".to_string()),  // Yellow ░
+        "snow" => Some("\x1b[37;1m\u{2744}\x1b[0m".to_string()), // White Bold ❄
+        "thunderstorm" => Some("\x1b[33;1m\u{26a1}\x1b[0m".to_string()), // Yellow Bold ⚡
+
+        // 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
+        "bel" => Some('\x07'.to_string()),      // Terminal Bell
+        "backspace" => Some('\x08'.to_string()), // Backspace
+
+        // 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
+        _ => 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;
+
+        Ok(test_examples(Char {})?)
+    }
+}

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

@@ -0,0 +1,53 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        if registry.get_command("chart bar").is_none() {
+            return Err(ShellError::untagged_runtime_error(
+                "nu_plugin_chart not installed.",
+            ));
+        }
+
+        let registry = registry.clone();
+        Ok(OutputStream::one(Ok(ReturnSuccess::Value(
+            UntaggedValue::string(crate::commands::help::get_help(&Chart, &registry))
+                .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;
+
+        Ok(test_examples(Chart {})?)
+    }
+}

crates/nu-cli/src/commands/classified/block.rs

@@ -0,0 +1,88 @@
+use crate::commands::classified::expr::run_expression_block;
+use crate::commands::classified::internal::run_internal_command;
+use crate::evaluation_context::EvaluationContext;
+use crate::prelude::*;
+use crate::stream::InputStream;
+use futures::stream::TryStreamExt;
+use nu_errors::ShellError;
+use nu_protocol::hir::{Block, ClassifiedCommand, Commands};
+use nu_protocol::{ReturnSuccess, Scope, UntaggedValue, Value};
+use std::sync::atomic::Ordering;
+
+pub(crate) async fn run_block(
+    block: &Block,
+    ctx: &mut EvaluationContext,
+    mut input: InputStream,
+    scope: Arc<Scope>,
+) -> Result<InputStream, ShellError> {
+    let mut output: Result<InputStream, ShellError> = Ok(InputStream::empty());
+    for pipeline in &block.block {
+        match output {
+            Ok(inp) if inp.is_empty() => {}
+            Ok(inp) => {
+                let mut output_stream = inp.to_output_stream();
+
+                loop {
+                    match output_stream.try_next().await {
+                        Ok(Some(ReturnSuccess::Value(Value {
+                            value: UntaggedValue::Error(e),
+                            ..
+                        }))) => return Err(e),
+                        Ok(Some(_item)) => {
+                            if let Some(err) = ctx.get_errors().get(0) {
+                                ctx.clear_errors();
+                                return Err(err.clone());
+                            }
+                            if ctx.ctrl_c.load(Ordering::SeqCst) {
+                                break;
+                            }
+                        }
+                        Ok(None) => {
+                            if let Some(err) = ctx.get_errors().get(0) {
+                                ctx.clear_errors();
+                                return Err(err.clone());
+                            }
+                            break;
+                        }
+                        Err(e) => return Err(e),
+                    }
+                }
+            }
+            Err(e) => {
+                return Err(e);
+            }
+        }
+        output = run_pipeline(pipeline, ctx, input, scope.clone()).await;
+
+        input = InputStream::empty();
+    }
+
+    output
+}
+
+async fn run_pipeline(
+    commands: &Commands,
+    ctx: &mut EvaluationContext,
+    mut input: InputStream,
+    scope: Arc<Scope>,
+) -> Result<InputStream, ShellError> {
+    for item in commands.list.clone() {
+        input = match item {
+            ClassifiedCommand::Dynamic(_) => {
+                return Err(ShellError::unimplemented("Dynamic commands"))
+            }
+
+            ClassifiedCommand::Expr(expr) => {
+                run_expression_block(*expr, ctx, scope.clone()).await?
+            }
+
+            ClassifiedCommand::Error(err) => return Err(err.into()),
+
+            ClassifiedCommand::Internal(left) => {
+                run_internal_command(left, ctx, input, scope.clone()).await?
+            }
+        };
+    }
+
+    Ok(input)
+}

crates/nu-cli/src/commands/classified/dynamic.rs

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

crates/nu-cli/src/commands/classified/expr.rs

@@ -0,0 +1,25 @@
+use crate::evaluate::evaluate_baseline_expr;
+use crate::prelude::*;
+
+use log::{log_enabled, trace};
+
+use futures::stream::once;
+use nu_errors::ShellError;
+use nu_protocol::hir::SpannedExpression;
+use nu_protocol::Scope;
+
+pub(crate) async fn run_expression_block(
+    expr: SpannedExpression,
+    context: &mut EvaluationContext,
+    scope: Arc<Scope>,
+) -> Result<InputStream, ShellError> {
+    if log_enabled!(log::Level::Trace) {
+        trace!(target: "nu::run::expr", "->");
+        trace!(target: "nu::run::expr", "{:?}", expr);
+    }
+
+    let registry = context.registry().clone();
+    let output = evaluate_baseline_expr(&expr, &registry, scope).await?;
+
+    Ok(once(async { Ok(output) }).to_input_stream())
+}

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

@@ -0,0 +1,696 @@
+use crate::commands::classified::maybe_text_codec::{MaybeTextCodec, StringOrBinary};
+use crate::evaluate::evaluate_baseline_expr;
+use crate::futures::ThreadedReceiver;
+use crate::prelude::*;
+
+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::{ExternalCommand, ExternalRedirection};
+use nu_protocol::{Primitive, Scope, ShellTypeName, UntaggedValue, Value};
+use nu_source::Tag;
+
+pub(crate) async fn run_external_command(
+    command: ExternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    scope: Arc<Scope>,
+    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, scope, external_redirection).await
+}
+
+async fn run_with_stdin(
+    command: ExternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    scope: Arc<Scope>,
+    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 value = evaluate_baseline_expr(arg, &context.registry, scope.clone()).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());
+                        }
+                        _ => {
+                            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);
+            }
+        }
+    }
+
+    let process_args = command_args
+        .iter()
+        .map(|arg| {
+            let home_dir;
+
+            #[cfg(feature = "dirs")]
+            {
+                home_dir = dirs::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 argument_contains_whitespace(&arg) && !argument_is_quoted(&arg) {
+                    add_quotes(&arg)
+                } 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,
+        scope,
+    )
+}
+
+fn spawn(
+    command: &ExternalCommand,
+    path: &str,
+    args: &[String],
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+    scope: Arc<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.env());
+
+    // 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))
+                        | UntaggedValue::Primitive(Primitive::Line(s)) => {
+                            if let Err(e) = stdin_write.write(s.as_bytes()) {
+                                let message = format!("Unable to write to stdin (error = {})", e);
+
+                                let _ = stdin_write_tx.send(Ok(Value {
+                                    value: UntaggedValue::Error(ShellError::labeled_error(
+                                        message,
+                                        "application may have closed before completing pipeline",
+                                        &stdin_name_tag,
+                                    )),
+                                    tag: stdin_name_tag,
+                                }));
+                                return Err(());
+                            }
+                        }
+                        UntaggedValue::Primitive(Primitive::Binary(b)) => {
+                            if let Err(e) = stdin_write.write(b) {
+                                let message = format!("Unable to write to stdin (error = {})", e);
+
+                                let _ = stdin_write_tx.send(Ok(Value {
+                                    value: UntaggedValue::Error(ShellError::labeled_error(
+                                        message,
+                                        "application may have closed before completing pipeline",
+                                        &stdin_name_tag,
+                                    )),
+                                    tag: stdin_name_tag,
+                                }));
+                                return Err(());
+                            }
+                        }
+                        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", "set", "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)
+}
+
+#[allow(unused)]
+pub fn argument_contains_whitespace(argument: &str) -> bool {
+    argument.chars().any(|c| c.is_whitespace())
+}
+
+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_quotes(argument: &str) -> String {
+    format!("\"{}\"", 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_quotes, argument_contains_whitespace, argument_is_quoted, expand_tilde, remove_quotes,
+    };
+    #[cfg(feature = "which")]
+    use super::{run_external_command, EvaluationContext, InputStream};
+
+    #[cfg(feature = "which")]
+    use futures::executor::block_on;
+    #[cfg(feature = "which")]
+    use nu_errors::ShellError;
+    #[cfg(feature = "which")]
+    use nu_protocol::Scope;
+    #[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 =
+            EvaluationContext::basic().expect("There was a problem creating a basic context.");
+
+        assert!(run_external_command(
+            cmd,
+            &mut ctx,
+            input,
+            Scope::create(),
+            ExternalRedirection::Stdout
+        )
+        .await
+        .is_err());
+
+        Ok(())
+    }
+
+    // async fn failure_run() -> Result<(), ShellError> {
+    //     let cmd = ExternalBuilder::for_name("fail").build();
+
+    //     let mut ctx = EvaluationContext::basic().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_contains_whitespace_from_argument_to_be_passed_in() {
+        assert_eq!(argument_contains_whitespace("andrés"), false);
+        assert_eq!(argument_contains_whitespace("and rés"), true);
+        assert_eq!(argument_contains_whitespace(r#"and\ rés"#), true);
+    }
+
+    #[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_quotes_to_argument_to_be_passed_in() {
+        assert_eq!(add_quotes("andrés"), "\"andrés\"");
+        //assert_eq!(add_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-cli/src/commands/classified/internal.rs

@@ -0,0 +1,267 @@
+use crate::commands::command::whole_stream_command;
+use crate::commands::run_alias::AliasCommand;
+use crate::commands::UnevaluatedCallInfo;
+use crate::prelude::*;
+use log::{log_enabled, trace};
+use nu_errors::ShellError;
+use nu_protocol::hir::{ExternalRedirection, InternalCommand};
+use nu_protocol::{CommandAction, Primitive, ReturnSuccess, Scope, UntaggedValue, Value};
+
+pub(crate) async fn run_internal_command(
+    command: InternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    scope: Arc<Scope>,
+) -> Result<InputStream, ShellError> {
+    if log_enabled!(log::Level::Trace) {
+        trace!(target: "nu::run::internal", "->");
+        trace!(target: "nu::run::internal", "{}", command.name);
+    }
+
+    let objects: InputStream = trace_stream!(target: "nu::trace_stream::internal", "input" = input);
+    let internal_command = context.expect_command(&command.name);
+
+    if command.name == "autoenv untrust" {
+        context.user_recently_used_autoenv_untrust = true;
+    }
+
+    let result = {
+        context
+            .run_command(
+                internal_command?,
+                Tag::unknown_anchor(command.name_span),
+                command.args.clone(),
+                scope.clone(),
+                objects,
+            )
+            .await?
+    };
+
+    let head = Arc::new(command.args.head.clone());
+    //let context = Arc::new(context.clone());
+    let context = context.clone();
+    let command = Arc::new(command);
+
+    Ok(InputStream::from_stream(
+        result
+            .then(move |item| {
+                let head = head.clone();
+                let command = command.clone();
+                let mut context = context.clone();
+                let scope = scope.clone();
+                async move {
+                    match item {
+                        Ok(ReturnSuccess::Action(action)) => match action {
+                            CommandAction::ChangePath(path) => {
+                                context.shell_manager.set_path(path);
+                                InputStream::from_stream(futures::stream::iter(vec![]))
+                            }
+                            CommandAction::Exit => std::process::exit(0), // TODO: save history.txt
+                            CommandAction::Error(err) => {
+                                context.error(err.clone());
+                                InputStream::one(UntaggedValue::Error(err).into_untagged_value())
+                            }
+                            CommandAction::AutoConvert(tagged_contents, extension) => {
+                                let contents_tag = tagged_contents.tag.clone();
+                                let command_name = format!("from {}", extension);
+                                let command = command.clone();
+                                if let Some(converter) = context.registry.get_command(&command_name)
+                                {
+                                    let new_args = 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: nu_protocol::hir::Call {
+                                                head: (&*head).clone(),
+                                                positional: None,
+                                                named: None,
+                                                span: Span::unknown(),
+                                                external_redirection: ExternalRedirection::Stdout,
+                                            },
+                                            name_tag: Tag::unknown_anchor(command.name_span),
+                                            scope,
+                                        },
+                                    };
+                                    let result = converter
+                                        .run(
+                                            new_args.with_input(vec![tagged_contents]),
+                                            &context.registry,
+                                        )
+                                        .await;
+
+                                    match result {
+                                        Ok(mut result) => {
+                                            let result_vec: Vec<Result<ReturnSuccess, ShellError>> =
+                                                result.drain_vec().await;
+
+                                            let mut output = vec![];
+                                            for res in result_vec {
+                                                match res {
+                                                    Ok(ReturnSuccess::Value(Value {
+                                                        value: UntaggedValue::Table(list),
+                                                        ..
+                                                    })) => {
+                                                        for l in list {
+                                                            output.push(Ok(l));
+                                                        }
+                                                    }
+                                                    Ok(ReturnSuccess::Value(Value {
+                                                        value,
+                                                        ..
+                                                    })) => {
+                                                        output
+                                                            .push(Ok(value
+                                                                .into_value(contents_tag.clone())));
+                                                    }
+                                                    Err(e) => output.push(Err(e)),
+                                                    _ => {}
+                                                }
+                                            }
+
+                                            futures::stream::iter(output).to_input_stream()
+                                        }
+                                        Err(e) => {
+                                            context.add_error(e);
+                                            InputStream::empty()
+                                        }
+                                    }
+                                } else {
+                                    InputStream::one(tagged_contents)
+                                }
+                            }
+                            CommandAction::EnterHelpShell(value) => match value {
+                                Value {
+                                    value: UntaggedValue::Primitive(Primitive::String(cmd)),
+                                    tag,
+                                } => {
+                                    context.shell_manager.insert_at_current(Box::new(
+                                        match HelpShell::for_command(
+                                            UntaggedValue::string(cmd).into_value(tag),
+                                            &context.registry(),
+                                        ) {
+                                            Ok(v) => v,
+                                            Err(err) => {
+                                                return InputStream::one(
+                                                    UntaggedValue::Error(err).into_untagged_value(),
+                                                )
+                                            }
+                                        },
+                                    ));
+                                    InputStream::from_stream(futures::stream::iter(vec![]))
+                                }
+                                _ => {
+                                    context.shell_manager.insert_at_current(Box::new(
+                                        match HelpShell::index(&context.registry()) {
+                                            Ok(v) => v,
+                                            Err(err) => {
+                                                return InputStream::one(
+                                                    UntaggedValue::Error(err).into_untagged_value(),
+                                                )
+                                            }
+                                        },
+                                    ));
+                                    InputStream::from_stream(futures::stream::iter(vec![]))
+                                }
+                            },
+                            CommandAction::EnterValueShell(value) => {
+                                context
+                                    .shell_manager
+                                    .insert_at_current(Box::new(ValueShell::new(value)));
+                                InputStream::from_stream(futures::stream::iter(vec![]))
+                            }
+                            CommandAction::EnterShell(location) => {
+                                context.shell_manager.insert_at_current(Box::new(
+                                    match FilesystemShell::with_location(location) {
+                                        Ok(v) => v,
+                                        Err(err) => {
+                                            return InputStream::one(
+                                                UntaggedValue::Error(err.into())
+                                                    .into_untagged_value(),
+                                            )
+                                        }
+                                    },
+                                ));
+                                InputStream::from_stream(futures::stream::iter(vec![]))
+                            }
+                            CommandAction::AddAlias(name, args, block) => {
+                                context.add_commands(vec![whole_stream_command(
+                                    AliasCommand::new(name, args, block),
+                                )]);
+                                InputStream::from_stream(futures::stream::iter(vec![]))
+                            }
+                            CommandAction::AddPlugins(path) => {
+                                match crate::plugin::scan(vec![std::path::PathBuf::from(path)]) {
+                                    Ok(plugins) => {
+                                        context.add_commands(
+                                            plugins
+                                                .into_iter()
+                                                .filter(|p| {
+                                                    !context.is_command_registered(p.name())
+                                                })
+                                                .collect(),
+                                        );
+
+                                        InputStream::from_stream(futures::stream::iter(vec![]))
+                                    }
+                                    Err(reason) => {
+                                        context.error(reason.clone());
+                                        InputStream::one(
+                                            UntaggedValue::Error(reason).into_untagged_value(),
+                                        )
+                                    }
+                                }
+                            }
+                            CommandAction::PreviousShell => {
+                                context.shell_manager.prev();
+                                InputStream::from_stream(futures::stream::iter(vec![]))
+                            }
+                            CommandAction::NextShell => {
+                                context.shell_manager.next();
+                                InputStream::from_stream(futures::stream::iter(vec![]))
+                            }
+                            CommandAction::LeaveShell => {
+                                context.shell_manager.remove_at_current();
+                                if context.shell_manager.is_empty() {
+                                    std::process::exit(0); // TODO: save history.txt
+                                }
+                                InputStream::from_stream(futures::stream::iter(vec![]))
+                            }
+                        },
+
+                        Ok(ReturnSuccess::Value(Value {
+                            value: UntaggedValue::Error(err),
+                            tag,
+                        })) => {
+                            context.error(err.clone());
+                            InputStream::one(UntaggedValue::Error(err).into_value(tag))
+                        }
+
+                        Ok(ReturnSuccess::Value(v)) => InputStream::one(v),
+
+                        Ok(ReturnSuccess::DebugValue(v)) => {
+                            let doc = PrettyDebug::pretty_doc(&v);
+                            let mut buffer = termcolor::Buffer::ansi();
+
+                            let _ = doc.render_raw(
+                                context.with_host(|host| host.width() - 5),
+                                &mut nu_source::TermColored::new(&mut buffer),
+                            );
+
+                            let value = String::from_utf8_lossy(buffer.as_slice());
+
+                            InputStream::one(UntaggedValue::string(value).into_untagged_value())
+                        }
+
+                        Err(err) => {
+                            context.error(err.clone());
+                            InputStream::one(UntaggedValue::Error(err).into_untagged_value())
+                        }
+                    }
+                }
+            })
+            .flatten()
+            .take_while(|x| futures::future::ready(!x.is_error())),
+    ))
+}

crates/nu-cli/src/commands/classified/maybe_text_codec.rs

@@ -0,0 +1,127 @@
+use bytes::{BufMut, Bytes, BytesMut};
+
+use nu_errors::ShellError;
+
+extern crate encoding_rs;
+use encoding_rs::{CoderResult, Decoder, Encoding, UTF_8};
+
+#[cfg(not(test))]
+const OUTPUT_BUFFER_SIZE: usize = 8192;
+#[cfg(test)]
+const OUTPUT_BUFFER_SIZE: usize = 4;
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum StringOrBinary {
+    String(String),
+    Binary(Vec<u8>),
+}
+
+pub struct MaybeTextCodec {
+    decoder: Decoder,
+}
+
+impl MaybeTextCodec {
+    // The constructor takes an Option<&'static Encoding>, because an absence of an encoding indicates that we want BOM sniffing enabled
+    pub fn new(encoding: Option<&'static Encoding>) -> Self {
+        let decoder = match encoding {
+            Some(e) => e.new_decoder_with_bom_removal(),
+            None => UTF_8.new_decoder(),
+        };
+        MaybeTextCodec { decoder }
+    }
+}
+
+impl Default for MaybeTextCodec {
+    fn default() -> Self {
+        MaybeTextCodec {
+            decoder: UTF_8.new_decoder(),
+        }
+    }
+}
+
+impl futures_codec::Encoder for MaybeTextCodec {
+    type Item = StringOrBinary;
+    type Error = std::io::Error;
+
+    fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        match item {
+            StringOrBinary::String(s) => {
+                dst.reserve(s.len());
+                dst.put(s.as_bytes());
+                Ok(())
+            }
+            StringOrBinary::Binary(b) => {
+                dst.reserve(b.len());
+                dst.put(Bytes::from(b));
+                Ok(())
+            }
+        }
+    }
+}
+
+impl futures_codec::Decoder for MaybeTextCodec {
+    type Item = StringOrBinary;
+    type Error = ShellError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if src.is_empty() {
+            return Ok(None);
+        }
+
+        let mut s = String::with_capacity(OUTPUT_BUFFER_SIZE);
+
+        let (res, _read, replacements) = self.decoder.decode_to_string(src, &mut s, false);
+
+        let result = if replacements {
+            // If we had to make replacements when converting to utf8, fall back to binary
+            StringOrBinary::Binary(src.to_vec())
+        } else {
+            // If original buffer size is too small, we continue to allocate new Strings and append
+            // them to the result until the input buffer is smaller than the allocated String
+            if let CoderResult::OutputFull = res {
+                let mut buffer = String::with_capacity(OUTPUT_BUFFER_SIZE);
+                loop {
+                    let (res, _read, _replacements) =
+                        self.decoder
+                            .decode_to_string(&src[s.len()..], &mut buffer, false);
+                    s.push_str(&buffer);
+
+                    if let CoderResult::InputEmpty = res {
+                        break;
+                    }
+
+                    buffer.clear();
+                }
+            }
+
+            StringOrBinary::String(s)
+        };
+
+        src.clear();
+
+        Ok(Some(result))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{MaybeTextCodec, StringOrBinary};
+    use bytes::BytesMut;
+    use futures_codec::Decoder;
+
+    // TODO: Write some more tests
+
+    #[test]
+    fn should_consume_all_bytes_from_source_when_temporary_buffer_overflows() {
+        let mut maybe_text = MaybeTextCodec::new(None);
+        let mut bytes = BytesMut::from("0123456789");
+
+        let text = maybe_text.decode(&mut bytes);
+
+        assert_eq!(
+            Ok(Some(StringOrBinary::String("0123456789".to_string()))),
+            text
+        );
+        assert!(bytes.is_empty());
+    }
+}

crates/nu-cli/src/commands/classified/mod.rs

@@ -1,7 +1,10 @@
+pub(crate) mod block;
 mod dynamic;
+pub(crate) mod expr;
 pub(crate) mod external;
 pub(crate) mod internal;
-pub(crate) mod pipeline;
+pub(crate) mod maybe_text_codec;
+pub(crate) mod plugin;
 
 #[allow(unused_imports)]
 pub(crate) use dynamic::Command as DynamicCommand;

crates/nu-cli/src/commands/classified/plugin.rs

@@ -0,0 +1,467 @@
+use crate::commands::command::{whole_stream_command, WholeStreamCommand};
+use crate::prelude::*;
+use derive_new::new;
+use log::trace;
+use nu_errors::ShellError;
+use nu_plugin::jsonrpc::JsonRpc;
+use nu_protocol::{Primitive, ReturnValue, Signature, UntaggedValue, Value};
+use serde::{self, Deserialize, Serialize};
+use std::io::prelude::*;
+use std::io::BufReader;
+use std::io::Write;
+use std::path::Path;
+use std::process::{Child, Command, Stdio};
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "method")]
+#[allow(non_camel_case_types)]
+pub enum NuResult {
+    response {
+        params: Result<VecDeque<ReturnValue>, ShellError>,
+    },
+}
+
+enum PluginCommand {
+    Filter(PluginFilter),
+    Sink(PluginSink),
+}
+
+impl PluginCommand {
+    fn command(self) -> Result<crate::commands::Command, ShellError> {
+        match self {
+            PluginCommand::Filter(cmd) => Ok(whole_stream_command(cmd)),
+            PluginCommand::Sink(cmd) => Ok(whole_stream_command(cmd)),
+        }
+    }
+}
+
+enum PluginMode {
+    Filter,
+    Sink,
+}
+
+pub struct PluginCommandBuilder {
+    mode: PluginMode,
+    name: String,
+    path: String,
+    config: Signature,
+}
+
+impl PluginCommandBuilder {
+    pub fn new(
+        name: impl Into<String>,
+        path: impl Into<String>,
+        config: impl Into<Signature>,
+    ) -> Self {
+        let config = config.into();
+
+        PluginCommandBuilder {
+            mode: if config.is_filter {
+                PluginMode::Filter
+            } else {
+                PluginMode::Sink
+            },
+            name: name.into(),
+            path: path.into(),
+            config,
+        }
+    }
+
+    pub fn build(&self) -> Result<crate::commands::Command, ShellError> {
+        let mode = &self.mode;
+
+        let name = self.name.clone();
+        let path = self.path.clone();
+        let config = self.config.clone();
+
+        let cmd = match mode {
+            PluginMode::Filter => PluginCommand::Filter(PluginFilter { name, path, config }),
+            PluginMode::Sink => PluginCommand::Sink(PluginSink { name, path, config }),
+        };
+
+        cmd.command()
+    }
+}
+
+#[derive(new)]
+pub struct PluginFilter {
+    name: String,
+    path: String,
+    config: Signature,
+}
+
+#[async_trait]
+impl WholeStreamCommand for PluginFilter {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn signature(&self) -> Signature {
+        self.config.clone()
+    }
+
+    fn usage(&self) -> &str {
+        &self.config.usage
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        run_filter(self.path.clone(), args, registry).await
+    }
+}
+
+async fn run_filter(
+    path: String,
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    trace!("filter_plugin :: {}", path);
+    let registry = registry.clone();
+
+    let scope = args.call_info.scope.clone();
+
+    let bos = futures::stream::iter(vec![
+        UntaggedValue::Primitive(Primitive::BeginningOfStream).into_untagged_value()
+    ]);
+    let eos = futures::stream::iter(vec![
+        UntaggedValue::Primitive(Primitive::EndOfStream).into_untagged_value()
+    ]);
+
+    let args = args.evaluate_once_with_scope(&registry, scope).await?;
+
+    let real_path = Path::new(&path);
+    let ext = real_path.extension();
+    let ps1_file = match ext {
+        Some(ext) => ext == "ps1",
+        None => false,
+    };
+
+    let mut child: Child = if ps1_file {
+        Command::new("pwsh")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .args(&[
+                "-NoLogo",
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-File",
+                &real_path.to_string_lossy(),
+            ])
+            .spawn()
+            .expect("Failed to spawn PowerShell process")
+    } else {
+        Command::new(path)
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .spawn()
+            .expect("Failed to spawn child process")
+    };
+
+    let call_info = args.call_info.clone();
+
+    trace!("filtering :: {:?}", call_info);
+
+    Ok(bos
+        .chain(args.input)
+        .chain(eos)
+        .map(move |item| {
+            match item {
+                Value {
+                    value: UntaggedValue::Primitive(Primitive::BeginningOfStream),
+                    ..
+                } => {
+                    // Beginning of the stream
+                    let stdin = child.stdin.as_mut().expect("Failed to open stdin");
+                    let stdout = child.stdout.as_mut().expect("Failed to open stdout");
+
+                    let mut reader = BufReader::new(stdout);
+
+                    let request = JsonRpc::new("begin_filter", call_info.clone());
+                    let request_raw = serde_json::to_string(&request);
+                    trace!("begin_filter:request {:?}", &request_raw);
+
+                    match request_raw {
+                        Err(_) => {
+                            return OutputStream::one(Err(ShellError::labeled_error(
+                                "Could not load json from plugin",
+                                "could not load json from plugin",
+                                &call_info.name_tag,
+                            )));
+                        }
+                        Ok(request_raw) => {
+                            match stdin.write(format!("{}\n", request_raw).as_bytes()) {
+                                Ok(_) => {}
+                                Err(err) => {
+                                    return OutputStream::one(Err(ShellError::unexpected(
+                                        format!("{}", err),
+                                    )));
+                                }
+                            }
+                        }
+                    }
+
+                    let mut input = String::new();
+                    match reader.read_line(&mut input) {
+                        Ok(_) => {
+                            let response = serde_json::from_str::<NuResult>(&input);
+                            trace!("begin_filter:response {:?}", &response);
+
+                            match response {
+                                Ok(NuResult::response { params }) => match params {
+                                    Ok(params) => futures::stream::iter(params).to_output_stream(),
+                                    Err(e) => futures::stream::iter(vec![ReturnValue::Err(e)])
+                                        .to_output_stream(),
+                                },
+
+                                Err(e) => OutputStream::one(Err(
+                                    ShellError::untagged_runtime_error(format!(
+                                        "Error while processing begin_filter response: {:?} {}",
+                                        e, input
+                                    )),
+                                )),
+                            }
+                        }
+                        Err(e) => OutputStream::one(Err(ShellError::untagged_runtime_error(
+                            format!("Error while reading begin_filter response: {:?}", e),
+                        ))),
+                    }
+                }
+                Value {
+                    value: UntaggedValue::Primitive(Primitive::EndOfStream),
+                    ..
+                } => {
+                    // post stream contents
+                    let stdin = child.stdin.as_mut().expect("Failed to open stdin");
+                    let stdout = child.stdout.as_mut().expect("Failed to open stdout");
+
+                    let mut reader = BufReader::new(stdout);
+
+                    let request: JsonRpc<std::vec::Vec<Value>> = JsonRpc::new("end_filter", vec![]);
+                    let request_raw = serde_json::to_string(&request);
+                    trace!("end_filter:request {:?}", &request_raw);
+
+                    match request_raw {
+                        Err(_) => {
+                            return OutputStream::one(Err(ShellError::labeled_error(
+                                "Could not load json from plugin",
+                                "could not load json from plugin",
+                                &call_info.name_tag,
+                            )));
+                        }
+                        Ok(request_raw) => {
+                            match stdin.write(format!("{}\n", request_raw).as_bytes()) {
+                                Ok(_) => {}
+                                Err(err) => {
+                                    return OutputStream::one(Err(ShellError::unexpected(
+                                        format!("{}", err),
+                                    )));
+                                }
+                            }
+                        }
+                    }
+
+                    let mut input = String::new();
+                    let stream = match reader.read_line(&mut input) {
+                        Ok(_) => {
+                            let response = serde_json::from_str::<NuResult>(&input);
+                            trace!("end_filter:response {:?}", &response);
+
+                            match response {
+                                Ok(NuResult::response { params }) => match params {
+                                    Ok(params) => futures::stream::iter(params).to_output_stream(),
+                                    Err(e) => futures::stream::iter(vec![ReturnValue::Err(e)])
+                                        .to_output_stream(),
+                                },
+                                Err(e) => futures::stream::iter(vec![Err(
+                                    ShellError::untagged_runtime_error(format!(
+                                        "Error while processing end_filter response: {:?} {}",
+                                        e, input
+                                    )),
+                                )])
+                                .to_output_stream(),
+                            }
+                        }
+                        Err(e) => {
+                            futures::stream::iter(vec![Err(ShellError::untagged_runtime_error(
+                                format!("Error while reading end_filter response: {:?}", e),
+                            ))])
+                            .to_output_stream()
+                        }
+                    };
+
+                    let stdin = child.stdin.as_mut().expect("Failed to open stdin");
+
+                    let request: JsonRpc<std::vec::Vec<Value>> = JsonRpc::new("quit", vec![]);
+                    let request_raw = serde_json::to_string(&request);
+                    trace!("quit:request {:?}", &request_raw);
+
+                    match request_raw {
+                        Ok(request_raw) => {
+                            let _ = stdin.write(format!("{}\n", request_raw).as_bytes());
+                            // TODO: Handle error
+                        }
+                        Err(e) => {
+                            return OutputStream::one(Err(ShellError::untagged_runtime_error(
+                                format!("Error while processing quit response: {:?}", e),
+                            )));
+                        }
+                    }
+                    let _ = child.wait();
+
+                    stream
+                }
+
+                v => {
+                    // Stream contents
+                    let stdin = child.stdin.as_mut().expect("Failed to open stdin");
+                    let stdout = child.stdout.as_mut().expect("Failed to open stdout");
+
+                    let mut reader = BufReader::new(stdout);
+
+                    let request = JsonRpc::new("filter", v);
+                    let request_raw = serde_json::to_string(&request);
+                    trace!("filter:request {:?}", &request_raw);
+
+                    match request_raw {
+                        Ok(request_raw) => {
+                            let _ = stdin.write(format!("{}\n", request_raw).as_bytes());
+                            // TODO: Handle error
+                        }
+                        Err(e) => {
+                            return OutputStream::one(Err(ShellError::untagged_runtime_error(
+                                format!("Error while processing filter response: {:?}", e),
+                            )));
+                        }
+                    }
+
+                    let mut input = String::new();
+                    match reader.read_line(&mut input) {
+                        Ok(_) => {
+                            let response = serde_json::from_str::<NuResult>(&input);
+                            trace!("filter:response {:?}", &response);
+
+                            match response {
+                                Ok(NuResult::response { params }) => match params {
+                                    Ok(params) => futures::stream::iter(params).to_output_stream(),
+                                    Err(e) => futures::stream::iter(vec![ReturnValue::Err(e)])
+                                        .to_output_stream(),
+                                },
+                                Err(e) => OutputStream::one(Err(
+                                    ShellError::untagged_runtime_error(format!(
+                                    "Error while processing filter response: {:?}\n== input ==\n{}",
+                                    e, input
+                                )),
+                                )),
+                            }
+                        }
+                        Err(e) => OutputStream::one(Err(ShellError::untagged_runtime_error(
+                            format!("Error while reading filter response: {:?}", e),
+                        ))),
+                    }
+                }
+            }
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+#[derive(new)]
+pub struct PluginSink {
+    name: String,
+    path: String,
+    config: Signature,
+}
+
+#[async_trait]
+impl WholeStreamCommand for PluginSink {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn signature(&self) -> Signature {
+        self.config.clone()
+    }
+
+    fn usage(&self) -> &str {
+        &self.config.usage
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        run_sink(self.path.clone(), args, registry).await
+    }
+}
+
+async fn run_sink(
+    path: String,
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let args = args.evaluate_once(&registry).await?;
+    let call_info = args.call_info.clone();
+
+    let input: Vec<Value> = args.input.collect().await;
+
+    let request = JsonRpc::new("sink", (call_info.clone(), input));
+    let request_raw = serde_json::to_string(&request);
+    if let Ok(request_raw) = request_raw {
+        if let Ok(mut tmpfile) = tempfile::NamedTempFile::new() {
+            let _ = writeln!(tmpfile, "{}", request_raw);
+            let _ = tmpfile.flush();
+
+            let real_path = Path::new(&path);
+            let ext = real_path.extension();
+            let ps1_file = match ext {
+                Some(ext) => ext == "ps1",
+                None => false,
+            };
+
+            // TODO: This sink may not work in powershell, trying to find
+            // an example of what CallInfo would look like in this temp file
+            let child = if ps1_file {
+                Command::new("pwsh")
+                    .args(&[
+                        "-NoLogo",
+                        "-NoProfile",
+                        "-ExecutionPolicy",
+                        "Bypass",
+                        "-File",
+                        &real_path.to_string_lossy(),
+                        &tmpfile
+                            .path()
+                            .to_str()
+                            .expect("Failed getting tmpfile path"),
+                    ])
+                    .spawn()
+            } else {
+                Command::new(path).arg(&tmpfile.path()).spawn()
+            };
+
+            if let Ok(mut child) = child {
+                let _ = child.wait();
+
+                Ok(OutputStream::empty())
+            } else {
+                Err(ShellError::untagged_runtime_error(
+                    "Could not create process for sink command",
+                ))
+            }
+        } else {
+            Err(ShellError::untagged_runtime_error(
+                "Could not open file to send sink command message",
+            ))
+        }
+    } else {
+        Err(ShellError::untagged_runtime_error(
+            "Could not create message to sink command",
+        ))
+    }
+}

crates/nu-cli/src/commands/clear.rs

@@ -0,0 +1,45 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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, _: &CommandRegistry) -> 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-cli/src/commands/clip.rs

@@ -0,0 +1,115 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use futures::stream::StreamExt;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, Value};
+
+use clipboard::{ClipboardContext, ClipboardProvider};
+
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        clip(args, registry).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,
+    _registry: &CommandRegistry,
+) -> 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(clip_context) = ClipboardProvider::new() {
+        let mut clip_context: ClipboardContext = clip_context;
+        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_str("\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_contents(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;
+
+        Ok(test_examples(Clip {})?)
+    }
+}

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

@@ -0,0 +1,340 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::help::get_help;
+use crate::deserializer::ConfigDeserializer;
+use crate::evaluate::evaluate_args::evaluate_args;
+use crate::prelude::*;
+use derive_new::new;
+use getset::Getters;
+use nu_errors::ShellError;
+use nu_protocol::hir;
+use nu_protocol::{CallInfo, EvaluatedArgs, ReturnSuccess, Scope, Signature, UntaggedValue, Value};
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use std::ops::Deref;
+use std::sync::atomic::AtomicBool;
+
+#[derive(Deserialize, Serialize, Debug, Clone)]
+pub struct UnevaluatedCallInfo {
+    pub args: hir::Call,
+    pub name_tag: Tag,
+    pub scope: Arc<Scope>,
+}
+
+impl UnevaluatedCallInfo {
+    pub async fn evaluate(self, registry: &CommandRegistry) -> Result<CallInfo, ShellError> {
+        let args = evaluate_args(&self.args, registry, self.scope.clone()).await?;
+
+        Ok(CallInfo {
+            args,
+            name_tag: self.name_tag,
+        })
+    }
+
+    pub fn switch_present(&self, switch: &str) -> bool {
+        self.args.switch_preset(switch)
+    }
+}
+
+#[derive(Getters)]
+#[get = "pub(crate)"]
+pub struct CommandArgs {
+    pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
+    pub ctrl_c: Arc<AtomicBool>,
+    pub current_errors: Arc<Mutex<Vec<ShellError>>>,
+    pub shell_manager: ShellManager,
+    pub call_info: UnevaluatedCallInfo,
+    pub input: InputStream,
+    pub raw_input: String,
+}
+
+#[derive(Getters, Clone)]
+#[get = "pub(crate)"]
+pub struct RawCommandArgs {
+    pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
+    pub ctrl_c: Arc<AtomicBool>,
+    pub current_errors: Arc<Mutex<Vec<ShellError>>>,
+    pub shell_manager: ShellManager,
+    pub call_info: UnevaluatedCallInfo,
+}
+
+impl RawCommandArgs {
+    pub fn with_input(self, input: impl Into<InputStream>) -> CommandArgs {
+        CommandArgs {
+            host: self.host,
+            ctrl_c: self.ctrl_c,
+            current_errors: self.current_errors,
+            shell_manager: self.shell_manager,
+            call_info: self.call_info,
+            input: input.into(),
+            raw_input: String::default(),
+        }
+    }
+}
+
+impl std::fmt::Debug for CommandArgs {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.call_info.fmt(f)
+    }
+}
+
+impl CommandArgs {
+    pub async fn evaluate_once(
+        self,
+        registry: &CommandRegistry,
+    ) -> Result<EvaluatedWholeStreamCommandArgs, ShellError> {
+        let host = self.host.clone();
+        let ctrl_c = self.ctrl_c.clone();
+        let shell_manager = self.shell_manager.clone();
+        let input = self.input;
+        let call_info = self.call_info.evaluate(registry).await?;
+
+        Ok(EvaluatedWholeStreamCommandArgs::new(
+            host,
+            ctrl_c,
+            shell_manager,
+            call_info,
+            input,
+        ))
+    }
+
+    pub async fn evaluate_once_with_scope(
+        self,
+        registry: &CommandRegistry,
+        scope: Arc<Scope>,
+    ) -> Result<EvaluatedWholeStreamCommandArgs, ShellError> {
+        let host = self.host.clone();
+        let ctrl_c = self.ctrl_c.clone();
+        let shell_manager = self.shell_manager.clone();
+        let input = self.input;
+        let call_info = UnevaluatedCallInfo {
+            name_tag: self.call_info.name_tag,
+            args: self.call_info.args,
+            scope: scope.clone(),
+        };
+        let call_info = call_info.evaluate(registry).await?;
+
+        Ok(EvaluatedWholeStreamCommandArgs::new(
+            host,
+            ctrl_c,
+            shell_manager,
+            call_info,
+            input,
+        ))
+    }
+
+    pub async fn process<'de, T: Deserialize<'de>>(
+        self,
+        registry: &CommandRegistry,
+    ) -> Result<(T, InputStream), ShellError> {
+        let args = self.evaluate_once(registry).await?;
+        let call_info = args.call_info.clone();
+
+        let mut deserializer = ConfigDeserializer::from_call_info(call_info);
+
+        Ok((T::deserialize(&mut deserializer)?, args.input))
+    }
+}
+
+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 registry: CommandRegistry,
+    pub name: Tag,
+    pub raw_input: String,
+}
+
+impl RunnableContext {
+    pub fn get_command(&self, name: &str) -> Option<Command> {
+        self.registry.get_command(name)
+    }
+}
+
+pub struct EvaluatedWholeStreamCommandArgs {
+    pub args: EvaluatedCommandArgs,
+    pub input: InputStream,
+}
+
+impl Deref for EvaluatedWholeStreamCommandArgs {
+    type Target = EvaluatedCommandArgs;
+    fn deref(&self) -> &Self::Target {
+        &self.args
+    }
+}
+
+impl EvaluatedWholeStreamCommandArgs {
+    pub fn new(
+        host: Arc<parking_lot::Mutex<dyn Host>>,
+        ctrl_c: Arc<AtomicBool>,
+        shell_manager: ShellManager,
+        call_info: CallInfo,
+        input: impl Into<InputStream>,
+    ) -> EvaluatedWholeStreamCommandArgs {
+        EvaluatedWholeStreamCommandArgs {
+            args: EvaluatedCommandArgs {
+                host,
+                ctrl_c,
+                shell_manager,
+                call_info,
+            },
+            input: input.into(),
+        }
+    }
+
+    pub fn name_tag(&self) -> Tag {
+        self.args.call_info.name_tag.clone()
+    }
+
+    pub fn parts(self) -> (InputStream, EvaluatedArgs) {
+        let EvaluatedWholeStreamCommandArgs { args, input } = self;
+
+        (input, args.call_info.args)
+    }
+
+    pub fn split(self) -> (InputStream, EvaluatedCommandArgs) {
+        let EvaluatedWholeStreamCommandArgs { args, input } = self;
+
+        (input, args)
+    }
+}
+
+#[derive(Getters, new)]
+#[get = "pub(crate)"]
+pub struct EvaluatedCommandArgs {
+    pub host: Arc<parking_lot::Mutex<dyn Host>>,
+    pub ctrl_c: Arc<AtomicBool>,
+    pub shell_manager: ShellManager,
+    pub call_info: CallInfo,
+}
+
+impl EvaluatedCommandArgs {
+    pub fn nth(&self, pos: usize) -> Option<&Value> {
+        self.call_info.args.nth(pos)
+    }
+
+    /// Get the nth positional argument, error if not possible
+    pub fn expect_nth(&self, pos: usize) -> Result<&Value, ShellError> {
+        self.call_info
+            .args
+            .nth(pos)
+            .ok_or_else(|| ShellError::unimplemented("Better error: expect_nth"))
+    }
+
+    pub fn get(&self, name: &str) -> Option<&Value> {
+        self.call_info.args.get(name)
+    }
+
+    pub fn has(&self, name: &str) -> bool {
+        self.call_info.args.has(name)
+    }
+}
+
+pub struct Example {
+    pub example: &'static str,
+    pub description: &'static str,
+    pub result: Option<Vec<Value>>,
+}
+
+#[async_trait]
+pub trait WholeStreamCommand: Send + Sync {
+    fn name(&self) -> &str;
+
+    fn signature(&self) -> Signature {
+        Signature::new(self.name()).desc(self.usage()).filter()
+    }
+
+    fn usage(&self) -> &str;
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError>;
+
+    fn is_binary(&self) -> bool {
+        false
+    }
+
+    // Commands that are not meant to be run by users
+    fn is_internal(&self) -> bool {
+        false
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        Vec::new()
+    }
+}
+
+#[derive(Clone)]
+pub struct Command(Arc<dyn WholeStreamCommand>);
+
+impl PrettyDebugWithSource for Command {
+    fn pretty_debug(&self, source: &str) -> DebugDocBuilder {
+        b::typed(
+            "whole stream command",
+            b::description(self.name())
+                + b::space()
+                + b::equals()
+                + b::space()
+                + self.signature().pretty_debug(source),
+        )
+    }
+}
+
+impl std::fmt::Debug for Command {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Command({})", self.name())
+    }
+}
+
+impl Command {
+    pub fn name(&self) -> &str {
+        self.0.name()
+    }
+
+    pub fn signature(&self) -> Signature {
+        self.0.signature()
+    }
+
+    pub fn usage(&self) -> &str {
+        self.0.usage()
+    }
+
+    pub fn examples(&self) -> Vec<Example> {
+        self.0.examples()
+    }
+
+    pub async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        if args.call_info.switch_present("help") {
+            let cl = self.0.clone();
+            let registry = registry.clone();
+            Ok(OutputStream::one(Ok(ReturnSuccess::Value(
+                UntaggedValue::string(get_help(&*cl, &registry)).into_value(Tag::unknown()),
+            ))))
+        } else {
+            self.0.run(args, registry).await
+        }
+    }
+
+    pub fn is_binary(&self) -> bool {
+        self.0.is_binary()
+    }
+
+    pub fn is_internal(&self) -> bool {
+        self.0.is_internal()
+    }
+
+    pub fn stream_command(&self) -> &dyn WholeStreamCommand {
+        &*self.0
+    }
+}
+
+pub fn whole_stream_command(command: impl WholeStreamCommand + 'static) -> Command {
+    Command(Arc::new(command))
+}

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

@@ -0,0 +1,95 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use futures::future;
+use futures::stream::StreamExt;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        compact(args, registry).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,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let (CompactArgs { rest: columns }, input) = args.process(&registry).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;
+
+        Ok(test_examples(Compact {})?)
+    }
+}

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

@@ -0,0 +1,57 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        clear(args, registry).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,
+    _registry: &CommandRegistry,
+) -> 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-cli/src/commands/config/command.rs

@@ -0,0 +1,37 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use crate::{CommandArgs, CommandRegistry, OutputStream};
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+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,
+        _registry: &CommandRegistry,
+    ) -> 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-cli/src/commands/config/get.rs

@@ -0,0 +1,76 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        get(args, registry).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,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let name_tag = args.call_info.name_tag.clone();
+    let (GetArgs { path }, _) = args.process(&registry).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-cli/src/commands/config/load.rs

@@ -0,0 +1,59 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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::Path,
+            "Path to load the config from",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Loads the config from the path given"
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        set(args, registry).await
+    }
+}
+
+pub async fn set(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> 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(&registry).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-cli/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-cli/src/commands/config/path.rs

@@ -0,0 +1,49 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        path(args, registry).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,
+    _registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let path = config::default_path()?;
+
+    Ok(OutputStream::one(ReturnSuccess::value(
+        UntaggedValue::Primitive(Primitive::Path(path)).into_value(args.call_info.name_tag),
+    )))
+}

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

@@ -0,0 +1,75 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        remove(args, registry).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,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let name_span = args.call_info.name_tag.clone();
+    let (RemoveArgs { remove }, _) = args.process(&registry).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-cli/src/commands/config/set.rs

@@ -0,0 +1,97 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+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,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        set(args, registry).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,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let name_tag = args.call_info.name_tag.clone();
+    let (SetArgs { path, mut value }, _) = args.process(&registry).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),
+    }
+}

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

@@ -0,0 +1,98 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+pub struct SetIntoArgs {
+    set_into: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config set_into"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config set_into").required(
+            "set_into",
+            SyntaxShape::String,
+            "sets a variable from values in the pipeline",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Sets a value in the config"
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        set_into(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Store the contents of the pipeline as a path",
+            example: "echo ['/usr/bin' '/bin'] | config set_into path",
+            result: None,
+        }]
+    }
+}
+
+pub async fn set_into(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let name_span = args.call_info.name_tag.clone();
+    let name = args.call_info.name_tag.clone();
+
+    let (SetIntoArgs { set_into: v }, input) = args.process(&registry).await?;
+
+    // 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)?;
+
+    // In the original code, this is set to `Some` if the `load flag is set`
+    let configuration = None;
+
+    let rows: Vec<Value> = input.collect().await;
+    let key = v.to_string();
+
+    Ok(if rows.is_empty() {
+        return Err(ShellError::labeled_error(
+            "No values given for set_into",
+            "needs value(s) from pipeline",
+            v.tag(),
+        ));
+    } else if rows.len() == 1 {
+        // A single value
+        let value = &rows[0];
+
+        result.insert(key, value.clone());
+
+        config::write(&result, &configuration)?;
+
+        OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::Row(result.into()).into_value(name),
+        ))
+    } else {
+        // Take in the pipeline as a table
+        let value = UntaggedValue::Table(rows).into_value(name.clone());
+
+        result.insert(key, value);
+
+        config::write(&result, &configuration)?;
+
+        OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::Row(result.into()).into_value(name),
+        ))
+    })
+}

crates/nu-cli/src/commands/constants.rs

@@ -0,0 +1,358 @@
+pub const BAT_LANGUAGES: &[&str] = &[
+    "as",
+    "csv",
+    "tsv",
+    "applescript",
+    "script editor",
+    "s",
+    "S",
+    "adoc",
+    "asciidoc",
+    "asc",
+    "asa",
+    "yasm",
+    "nasm",
+    "asm",
+    "inc",
+    "mac",
+    "awk",
+    "bat",
+    "cmd",
+    "bib",
+    "sh",
+    "bash",
+    "zsh",
+    ".bash_aliases",
+    ".bash_completions",
+    ".bash_functions",
+    ".bash_login",
+    ".bash_logout",
+    ".bash_profile",
+    ".bash_variables",
+    ".bashrc",
+    ".profile",
+    ".textmate_init",
+    ".zshrc",
+    "PKGBUILD",
+    ".ebuild",
+    ".eclass",
+    "c",
+    "h",
+    "cs",
+    "csx",
+    "cpp",
+    "cc",
+    "cp",
+    "cxx",
+    "c++",
+    "C",
+    "h",
+    "hh",
+    "hpp",
+    "hxx",
+    "h++",
+    "inl",
+    "ipp",
+    "cabal",
+    "clj",
+    "cljc",
+    "cljs",
+    "edn",
+    "CMakeLists.txt",
+    "cmake",
+    "h.in",
+    "hh.in",
+    "hpp.in",
+    "hxx.in",
+    "h++.in",
+    "CMakeCache.txt",
+    "cr",
+    "css",
+    "css.erb",
+    "css.liquid",
+    "d",
+    "di",
+    "dart",
+    "diff",
+    "patch",
+    "Dockerfile",
+    "dockerfile",
+    "ex",
+    "exs",
+    "elm",
+    "erl",
+    "hrl",
+    "Emakefile",
+    "emakefile",
+    "fs",
+    "fsi",
+    "fsx",
+    "fs",
+    "fsi",
+    "fsx",
+    "fish",
+    "attributes",
+    "gitattributes",
+    ".gitattributes",
+    "COMMIT_EDITMSG",
+    "MERGE_MSG",
+    "TAG_EDITMSG",
+    "gitconfig",
+    ".gitconfig",
+    ".gitmodules",
+    "exclude",
+    "gitignore",
+    ".gitignore",
+    ".git",
+    "gitlog",
+    "git-rebase-todo",
+    "go",
+    "dot",
+    "DOT",
+    "gv",
+    "groovy",
+    "gvy",
+    "gradle",
+    "Jenkinsfile",
+    "hs",
+    "hs",
+    "hsc",
+    "show-nonprintable",
+    "html",
+    "htm",
+    "shtml",
+    "xhtml",
+    "asp",
+    "html.eex",
+    "yaws",
+    "rails",
+    "rhtml",
+    "erb",
+    "html.erb",
+    "adp",
+    "twig",
+    "html.twig",
+    "ini",
+    "INI",
+    "INF",
+    "reg",
+    "REG",
+    "lng",
+    "cfg",
+    "CFG",
+    "desktop",
+    "url",
+    "URL",
+    ".editorconfig",
+    ".hgrc",
+    "hgrc",
+    "java",
+    "bsh",
+    "properties",
+    "jsp",
+    "js",
+    "htc",
+    "js",
+    "jsx",
+    "babel",
+    "es6",
+    "js.erb",
+    "json",
+    "sublime-settings",
+    "sublime-menu",
+    "sublime-keymap",
+    "sublime-mousemap",
+    "sublime-theme",
+    "sublime-build",
+    "sublime-project",
+    "sublime-completions",
+    "sublime-commands",
+    "sublime-macro",
+    "sublime-color-scheme",
+    "ipynb",
+    "Pipfile.lock",
+    "jsonnet",
+    "libsonnet",
+    "libjsonnet",
+    "jl",
+    "kt",
+    "kts",
+    "tex",
+    "ltx",
+    "less",
+    "css.less",
+    "lisp",
+    "cl",
+    "clisp",
+    "l",
+    "mud",
+    "el",
+    "scm",
+    "ss",
+    "lsp",
+    "fasl",
+    "lhs",
+    "lua",
+    "make",
+    "GNUmakefile",
+    "makefile",
+    "Makefile",
+    "makefile.am",
+    "Makefile.am",
+    "makefile.in",
+    "Makefile.in",
+    "OCamlMakefile",
+    "mak",
+    "mk",
+    "md",
+    "mdown",
+    "markdown",
+    "markdn",
+    "matlab",
+    "build",
+    "nix",
+    "m",
+    "h",
+    "mm",
+    "M",
+    "h",
+    "ml",
+    "mli",
+    "mll",
+    "mly",
+    "pas",
+    "p",
+    "dpr",
+    "pl",
+    "pm",
+    "pod",
+    "t",
+    "PL",
+    "php",
+    "php3",
+    "php4",
+    "php5",
+    "php7",
+    "phps",
+    "phpt",
+    "phtml",
+    "txt",
+    "ps1",
+    "psm1",
+    "psd1",
+    "proto",
+    "protodevel",
+    "pb.txt",
+    "proto.text",
+    "textpb",
+    "pbtxt",
+    "prototxt",
+    "pp",
+    "epp",
+    "purs",
+    "py",
+    "py3",
+    "pyw",
+    "pyi",
+    "pyx",
+    "pyx.in",
+    "pxd",
+    "pxd.in",
+    "pxi",
+    "pxi.in",
+    "rpy",
+    "cpy",
+    "SConstruct",
+    "Sconstruct",
+    "sconstruct",
+    "SConscript",
+    "gyp",
+    "gypi",
+    "Snakefile",
+    "wscript",
+    "R",
+    "r",
+    "s",
+    "S",
+    "Rprofile",
+    "rd",
+    "re",
+    "rst",
+    "rest",
+    "robot",
+    "rb",
+    "Appfile",
+    "Appraisals",
+    "Berksfile",
+    "Brewfile",
+    "capfile",
+    "cgi",
+    "Cheffile",
+    "config.ru",
+    "Deliverfile",
+    "Fastfile",
+    "fcgi",
+    "Gemfile",
+    "gemspec",
+    "Guardfile",
+    "irbrc",
+    "jbuilder",
+    "Podfile",
+    "podspec",
+    "prawn",
+    "rabl",
+    "rake",
+    "Rakefile",
+    "Rantfile",
+    "rbx",
+    "rjs",
+    "ruby.rail",
+    "Scanfile",
+    "simplecov",
+    "Snapfile",
+    "thor",
+    "Thorfile",
+    "Vagrantfile",
+    "haml",
+    "sass",
+    "rxml",
+    "builder",
+    "rs",
+    "scala",
+    "sbt",
+    "sql",
+    "ddl",
+    "dml",
+    "erbsql",
+    "sql.erb",
+    "swift",
+    "log",
+    "tcl",
+    "tf",
+    "tfvars",
+    "hcl",
+    "sty",
+    "cls",
+    "textile",
+    "toml",
+    "tml",
+    "Cargo.lock",
+    "Gopkg.lock",
+    "Pipfile",
+    "ts",
+    "tsx",
+    "varlink",
+    "vim",
+    ".vimrc",
+    "xml",
+    "xsd",
+    "xslt",
+    "tld",
+    "dtml",
+    "rss",
+    "opml",
+    "svg",
+    "yaml",
+    "yml",
+    "sublime-syntax",
+];

crates/nu-cli/src/commands/count.rs

@@ -0,0 +1,91 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use futures::stream::StreamExt;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, UntaggedValue, Value};
+
+pub struct Count;
+
+#[derive(Deserialize)]
+pub struct CountArgs {
+    column: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Count {
+    fn name(&self) -> &str {
+        "count"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("count").switch(
+            "column",
+            "Calculate number of columns in table",
+            Some('c'),
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Show the total number of rows or items."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let (CountArgs { column }, input) = args.process(&registry).await?;
+        let rows: Vec<Value> = input.collect().await;
+
+        let count = if column {
+            if rows.is_empty() {
+                0
+            } else {
+                match &rows[0].value {
+                    UntaggedValue::Row(dictionary) => dictionary.length(),
+                    _ => {
+                        return Err(ShellError::labeled_error(
+                            "Cannot obtain column count",
+                            "cannot obtain column count",
+                            tag,
+                        ));
+                    }
+                }
+            }
+        } else {
+            rows.len()
+        };
+
+        Ok(OutputStream::one(UntaggedValue::int(count).into_value(tag)))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Count the number of entries in a list",
+                example: "echo [1 2 3 4 5] | count",
+                result: Some(vec![UntaggedValue::int(5).into()]),
+            },
+            Example {
+                description: "Count the number of columns in the calendar table",
+                example: "cal | count -c",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Count;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Count {})?)
+    }
+}

crates/nu-cli/src/commands/cp.rs

@@ -0,0 +1,77 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape};
+use nu_source::Tagged;
+use std::path::PathBuf;
+
+pub struct Cpy;
+
+#[derive(Deserialize)]
+pub struct CopyArgs {
+    pub src: Tagged<PathBuf>,
+    pub dst: Tagged<PathBuf>,
+    pub recursive: Tagged<bool>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Cpy {
+    fn name(&self) -> &str {
+        "cp"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("cp")
+            .required("src", SyntaxShape::Pattern, "the place to copy from")
+            .required("dst", SyntaxShape::Path, "the place to copy to")
+            .switch(
+                "recursive",
+                "copy recursively through subdirectories",
+                Some('r'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Copy files."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let shell_manager = args.shell_manager.clone();
+        let name = args.call_info.name_tag.clone();
+        let (args, _) = args.process(&registry).await?;
+        shell_manager.cp(args, name)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Copy myfile to dir_b",
+                example: "cp myfile dir_b",
+                result: None,
+            },
+            Example {
+                description: "Recursively copy dir_a to dir_b",
+                example: "cp -r dir_a dir_b",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Cpy;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Cpy {})?)
+    }
+}

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

@@ -0,0 +1,47 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "date"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date")
+    }
+
+    fn usage(&self) -> &str {
+        "Apply date function"
+    }
+
+    async fn run(
+        &self,
+        _args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let registry = registry.clone();
+
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(crate::commands::help::get_help(&Command, &registry))
+                .into_value(Tag::unknown()),
+        )))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Command;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Command {})?)
+    }
+}

crates/nu-cli/src/commands/date/format.rs

@@ -0,0 +1,76 @@
+use crate::prelude::*;
+use chrono::{DateTime, Local};
+use nu_errors::ShellError;
+
+use crate::commands::date::utils::{date_to_value, date_to_value_raw};
+use crate::commands::WholeStreamCommand;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct Date;
+
+#[derive(Deserialize)]
+pub struct FormatArgs {
+    format: Tagged<String>,
+    raw: Option<bool>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date format"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date format")
+            .required("format", SyntaxShape::String, "strftime format")
+            .switch("raw", "print date without tables", Some('r'))
+    }
+
+    fn usage(&self) -> &str {
+        "format the current date using the given format string."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        format(args, registry).await
+    }
+}
+
+pub async fn format(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let tag = args.call_info.name_tag.clone();
+    let (FormatArgs { format, raw }, _) = args.process(&registry).await?;
+
+    let dt_fmt = format.to_string();
+
+    let value = {
+        let local: DateTime<Local> = Local::now();
+        if let Some(true) = raw {
+            UntaggedValue::string(date_to_value_raw(local, dt_fmt)).into_untagged_value()
+        } else {
+            date_to_value(local, tag, dt_fmt)
+        }
+    };
+
+    Ok(OutputStream::one(value))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-cli/src/commands/date/mod.rs

@@ -0,0 +1,11 @@
+pub mod command;
+pub mod format;
+pub mod now;
+pub mod utc;
+
+mod utils;
+
+pub use command::Command as Date;
+pub use format::Date as DateFormat;
+pub use now::Date as DateNow;
+pub use utc::Date as DateUTC;

crates/nu-cli/src/commands/date/now.rs

@@ -0,0 +1,63 @@
+use crate::prelude::*;
+use chrono::{DateTime, Local};
+use nu_errors::ShellError;
+
+use crate::commands::date::utils::date_to_value;
+use crate::commands::WholeStreamCommand;
+use nu_protocol::Signature;
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date now"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date now")
+    }
+
+    fn usage(&self) -> &str {
+        "return the current date."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        now(args, registry).await
+    }
+}
+
+pub async fn now(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let args = args.evaluate_once(&registry).await?;
+    let tag = args.call_info.name_tag.clone();
+
+    let no_fmt = "".to_string();
+
+    let value = {
+        let local: DateTime<Local> = Local::now();
+        date_to_value(local, tag, no_fmt)
+    };
+
+    Ok(OutputStream::one(value))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-cli/src/commands/date/utc.rs

@@ -0,0 +1,63 @@
+use crate::prelude::*;
+use chrono::{DateTime, Utc};
+use nu_errors::ShellError;
+
+use crate::commands::date::utils::date_to_value;
+use crate::commands::WholeStreamCommand;
+use nu_protocol::Signature;
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date utc"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date utc")
+    }
+
+    fn usage(&self) -> &str {
+        "return the current date in utc."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        utc(args, registry).await
+    }
+}
+
+pub async fn utc(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let args = args.evaluate_once(&registry).await?;
+    let tag = args.call_info.name_tag.clone();
+
+    let no_fmt = "".to_string();
+
+    let value = {
+        let local: DateTime<Utc> = Utc::now();
+        date_to_value(local, tag, no_fmt)
+    };
+
+    Ok(OutputStream::one(value))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-cli/src/commands/date/utils.rs

@@ -0,0 +1,64 @@
+use crate::prelude::*;
+use chrono::DateTime;
+use nu_protocol::{Dictionary, Value};
+
+use chrono::{Datelike, TimeZone, Timelike};
+use core::fmt::Display;
+use indexmap::IndexMap;
+use nu_protocol::UntaggedValue;
+
+pub fn date_to_value_raw<T: TimeZone>(dt: DateTime<T>, dt_format: String) -> String
+where
+    T::Offset: Display,
+{
+    let result = dt.format(&dt_format);
+    format!("{}", result)
+}
+
+pub fn date_to_value<T: TimeZone>(dt: DateTime<T>, tag: Tag, dt_format: String) -> Value
+where
+    T::Offset: Display,
+{
+    let mut indexmap = IndexMap::new();
+
+    if dt_format.is_empty() {
+        indexmap.insert(
+            "year".to_string(),
+            UntaggedValue::int(dt.year()).into_value(&tag),
+        );
+        indexmap.insert(
+            "month".to_string(),
+            UntaggedValue::int(dt.month()).into_value(&tag),
+        );
+        indexmap.insert(
+            "day".to_string(),
+            UntaggedValue::int(dt.day()).into_value(&tag),
+        );
+        indexmap.insert(
+            "hour".to_string(),
+            UntaggedValue::int(dt.hour()).into_value(&tag),
+        );
+        indexmap.insert(
+            "minute".to_string(),
+            UntaggedValue::int(dt.minute()).into_value(&tag),
+        );
+        indexmap.insert(
+            "second".to_string(),
+            UntaggedValue::int(dt.second()).into_value(&tag),
+        );
+
+        let tz = dt.offset();
+        indexmap.insert(
+            "timezone".to_string(),
+            UntaggedValue::string(format!("{}", tz)).into_value(&tag),
+        );
+    } else {
+        let result = dt.format(&dt_format);
+        indexmap.insert(
+            "formatted".to_string(),
+            UntaggedValue::string(format!("{}", result)).into_value(&tag),
+        );
+    }
+
+    UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag)
+}

crates/nu-cli/src/commands/debug.rs

@@ -10,6 +10,7 @@ pub struct DebugArgs {
     raw: bool,
 }
 
+#[async_trait]
 impl WholeStreamCommand for Debug {
     fn name(&self) -> &str {
         "debug"
@@ -23,21 +24,22 @@ impl WholeStreamCommand for Debug {
         "Print the Rust debug representation of the values"
     }
 
-    fn run(
+    async fn run(
         &self,
         args: CommandArgs,
         registry: &CommandRegistry,
     ) -> Result<OutputStream, ShellError> {
-        args.process(registry, debug_value)?.run()
+        debug_value(args, registry).await
     }
 }
 
-fn debug_value(
-    DebugArgs { raw }: DebugArgs,
-    RunnableContext { input, .. }: RunnableContext,
-) -> Result<impl ToOutputStream, ShellError> {
+async fn debug_value(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let (DebugArgs { raw }, input) = args.process(&registry).await?;
     Ok(input
-        .values
         .map(move |v| {
             if raw {
                 ReturnSuccess::value(
@@ -49,3 +51,16 @@ fn debug_value(
         })
         .to_output_stream())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Debug;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Debug {})?)
+    }
+}

crates/nu-cli/src/commands/default.rs

@@ -1,5 +1,5 @@
+use crate::command_registry::CommandRegistry;
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
@@ -14,6 +14,7 @@ struct DefaultArgs {
 
 pub struct Default;
 
+#[async_trait]
 impl WholeStreamCommand for Default {
     fn name(&self) -> &str {
         "default"
@@ -33,44 +34,61 @@ impl WholeStreamCommand for Default {
         "Sets a default row's column if missing."
     }
 
-    fn run(
+    async fn run(
         &self,
         args: CommandArgs,
         registry: &CommandRegistry,
     ) -> Result<OutputStream, ShellError> {
-        args.process(registry, default)?.run()
+        default(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Give a default 'target' to all file entries",
+            example: "ls -la | default target 'nothing'",
+            result: None,
+        }]
     }
 }
 
-fn default(
-    DefaultArgs { column, value }: DefaultArgs,
-    RunnableContext { input, .. }: RunnableContext,
+async fn default(
+    args: CommandArgs,
+    registry: &CommandRegistry,
 ) -> Result<OutputStream, ShellError> {
-    let stream = input
-        .values
-        .map(move |item| {
-            let mut result = VecDeque::new();
+    let registry = registry.clone();
+    let (DefaultArgs { column, value }, input) = args.process(&registry).await?;
 
-            let should_add = match item {
+    Ok(input
+        .map(move |item| {
+            let should_add = matches!(
+                item,
                 Value {
                     value: UntaggedValue::Row(ref r),
                     ..
-                } => r.get_data(&column.item).borrow().is_none(),
-                _ => false,
-            };
+                } if r.get_data(&column.item).borrow().is_none()
+            );
 
             if should_add {
                 match item.insert_data_at_path(&column.item, value.clone()) {
-                    Some(new_value) => result.push_back(ReturnSuccess::value(new_value)),
-                    None => result.push_back(ReturnSuccess::value(item)),
+                    Some(new_value) => ReturnSuccess::value(new_value),
+                    None => ReturnSuccess::value(item),
                 }
             } else {
-                result.push_back(ReturnSuccess::value(item));
+                ReturnSuccess::value(item)
             }
-
-            futures::stream::iter(result)
         })
-        .flatten();
-
-    Ok(stream.to_output_stream())
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Default;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Default {})?)
+    }
 }

crates/nu-cli/src/commands/describe.rs

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

crates/nu-cli/src/commands/do_.rs

@@ -0,0 +1,128 @@
+use crate::commands::classified::block::run_block;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::Block, hir::ExternalRedirection, ReturnSuccess, Signature, SyntaxShape, Value,
+};
+
+pub struct Do;
+
+#[derive(Deserialize, Debug)]
+struct DoArgs {
+    block: Block,
+    ignore_errors: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Do {
+    fn name(&self) -> &str {
+        "do"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("do")
+            .required("block", SyntaxShape::Block, "the block to run ")
+            .switch(
+                "ignore_errors",
+                "ignore errors as the block runs",
+                Some('i'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block, optionally ignoring errors"
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        do_(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Run the block",
+                example: r#"do { echo hello }"#,
+                result: Some(vec![Value::from("hello")]),
+            },
+            Example {
+                description: "Run the block and ignore errors",
+                example: r#"do -i { thisisnotarealcommand }"#,
+                result: Some(vec![Value::nothing()]),
+            },
+        ]
+    }
+}
+
+async fn do_(
+    raw_args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let external_redirection = raw_args.call_info.args.external_redirection;
+
+    let mut context = EvaluationContext::from_raw(&raw_args, &registry);
+    let scope = raw_args.call_info.scope.clone();
+    let (
+        DoArgs {
+            ignore_errors,
+            mut block,
+        },
+        input,
+    ) = raw_args.process(&registry).await?;
+
+    let block_redirection = match external_redirection {
+        ExternalRedirection::None => {
+            if ignore_errors {
+                ExternalRedirection::Stderr
+            } else {
+                ExternalRedirection::None
+            }
+        }
+        ExternalRedirection::Stdout => {
+            if ignore_errors {
+                ExternalRedirection::StdoutAndStderr
+            } else {
+                ExternalRedirection::Stdout
+            }
+        }
+        x => x,
+    };
+
+    block.set_redirect(block_redirection);
+
+    let result = run_block(&block, &mut context, input, scope).await;
+
+    if ignore_errors {
+        // To properly ignore errors we need to redirect stderr, consume it, and remove
+        // any errors we see in the process.
+
+        match result {
+            Ok(mut stream) => {
+                let output = stream.drain_vec().await;
+                context.clear_errors();
+                Ok(futures::stream::iter(output).to_output_stream())
+            }
+            Err(_) => Ok(OutputStream::one(ReturnSuccess::value(Value::nothing()))),
+        }
+    } else {
+        result.map(|x| x.to_output_stream())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Do;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Do {})?)
+    }
+}

crates/nu-cli/src/commands/drop.rs

@@ -0,0 +1,96 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct Drop;
+
+#[derive(Deserialize)]
+pub struct DropArgs {
+    rows: Option<Tagged<u64>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Drop {
+    fn name(&self) -> &str {
+        "drop"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("drop").optional(
+            "rows",
+            SyntaxShape::Number,
+            "starting from the back, the number of rows to remove",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Remove the last number of rows. If you want to remove columns, try 'reject'."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        drop(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Remove the last item of a list/table",
+                example: "echo [1 2 3] | drop",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(2).into(),
+                ]),
+            },
+            Example {
+                description: "Remove the last 2 items of a list/table",
+                example: "echo [1 2 3] | drop 2",
+                result: Some(vec![UntaggedValue::int(1).into()]),
+            },
+        ]
+    }
+}
+
+async fn drop(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    let (DropArgs { rows }, input) = args.process(&registry).await?;
+    let v: Vec<_> = input.into_vec().await;
+
+    let rows_to_drop = if let Some(quantity) = rows {
+        *quantity as usize
+    } else {
+        1
+    };
+
+    Ok(if rows_to_drop == 0 {
+        futures::stream::iter(v).to_output_stream()
+    } else {
+        let k = if v.len() < rows_to_drop {
+            0
+        } else {
+            v.len() - rows_to_drop
+        };
+
+        let iter = v.into_iter().take(k);
+
+        futures::stream::iter(iter).to_output_stream()
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Drop;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Drop {})?)
+    }
+}

crates/nu-cli/src/commands/du.rs

@@ -1,12 +1,10 @@
-extern crate filesize;
-
-use crate::commands::command::RunnablePerItemContext;
+use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
 use filesize::file_real_size_fast;
 use glob::*;
 use indexmap::map::IndexMap;
 use nu_errors::ShellError;
-use nu_protocol::{CallInfo, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
 use nu_source::Tagged;
 use std::path::PathBuf;
 use std::sync::atomic::Ordering;
@@ -32,7 +30,8 @@ pub struct DuArgs {
     min_size: Option<Tagged<u64>>,
 }
 
-impl PerItemCommand for Du {
+#[async_trait]
+impl WholeStreamCommand for Du {
     fn name(&self) -> &str {
         NAME
     }
@@ -42,7 +41,7 @@ impl PerItemCommand for Du {
             .optional("path", SyntaxShape::Pattern, "starting directory")
             .switch(
                 "all",
-                "Output File sizes as well as directory sizes",
+                "Output file sizes as well as directory sizes",
                 Some('a'),
             )
             .switch(
@@ -74,115 +73,121 @@ impl PerItemCommand for Du {
         "Find disk usage sizes of specified items"
     }
 
-    fn run(
+    async fn run(
         &self,
-        call_info: &CallInfo,
-        _registry: &CommandRegistry,
-        raw_args: &RawCommandArgs,
-        _input: Value,
+        args: CommandArgs,
+        registry: &CommandRegistry,
     ) -> Result<OutputStream, ShellError> {
-        call_info
-            .process(&raw_args.shell_manager, raw_args.ctrl_c.clone(), du)?
-            .run()
+        du(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Disk usage of the current directory",
+            example: "du",
+            result: None,
+        }]
     }
 }
 
-fn du(args: DuArgs, ctx: &RunnablePerItemContext) -> Result<OutputStream, ShellError> {
-    let tag = ctx.name.clone();
+async fn du(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let tag = args.call_info.name_tag.clone();
+    let ctrl_c = args.ctrl_c.clone();
+    let ctrl_c_copy = ctrl_c.clone();
 
-    let exclude = args
-        .exclude
-        .clone()
-        .map_or(Ok(None), move |x| match Pattern::new(&x.item) {
-            Ok(p) => Ok(Some(p)),
-            Err(e) => Err(ShellError::labeled_error(
-                e.msg,
-                "Glob error",
-                x.tag.clone(),
-            )),
-        })?;
-    let path = args.path.clone();
-    let filter_files = path.is_none();
-    let paths = match path {
-        Some(p) => match glob::glob_with(
-            p.item.to_str().expect("Why isn't this encoded properly?"),
-            GLOB_PARAMS,
-        ) {
-            Ok(g) => Ok(g),
-            Err(e) => Err(ShellError::labeled_error(
-                e.msg,
-                "Glob error",
-                p.tag.clone(),
-            )),
-        },
-        None => match glob::glob_with("*", GLOB_PARAMS) {
-            Ok(g) => Ok(g),
-            Err(e) => Err(ShellError::labeled_error(e.msg, "Glob error", tag.clone())),
-        },
-    }?
+    let (args, _): (DuArgs, _) = args.process(&registry).await?;
+    let exclude = args.exclude.map_or(Ok(None), move |x| {
+        Pattern::new(&x.item)
+            .map(Option::Some)
+            .map_err(|e| ShellError::labeled_error(e.msg, "glob error", x.tag.clone()))
+    })?;
+
+    let include_files = args.all;
+    let paths = match args.path {
+        Some(p) => {
+            let p = p.item.to_str().expect("Why isn't this encoded properly?");
+            glob::glob_with(p, GLOB_PARAMS)
+        }
+        None => glob::glob_with("*", GLOB_PARAMS),
+    }
+    .map_err(|e| ShellError::labeled_error(e.msg, "glob error", tag.clone()))?
     .filter(move |p| {
-        if filter_files {
+        if include_files {
+            true
+        } else {
             match p {
                 Ok(f) if f.is_dir() => true,
                 Err(e) if e.path().is_dir() => true,
                 _ => false,
             }
-        } else {
-            true
         }
     })
-    .map(move |p| match p {
-        Err(e) => Err(glob_err_into(e)),
-        Ok(s) => Ok(s),
-    });
+    .map(|v| v.map_err(glob_err_into));
 
-    let ctrl_c = ctx.ctrl_c.clone();
     let all = args.all;
     let deref = args.deref;
     let max_depth = args.max_depth.map(|f| f.item);
     let min_size = args.min_size.map(|f| f.item);
 
-    let stream = async_stream! {
-        let params = DirBuilder {
-            tag: tag.clone(),
-            min: min_size,
-            deref,
-            ex: exclude,
-            all,
-        };
-        for path in paths {
-            if ctrl_c.load(Ordering::SeqCst) {
-                break;
-            }
-            match path {
-                Ok(p) => {
-                    if p.is_dir() {
-                        yield Ok(ReturnSuccess::Value(
-                            DirInfo::new(p, &params, max_depth).into(),
-                        ));
-                    } else {
-                        match FileInfo::new(p, deref, tag.clone()) {
-                            Ok(f) => yield Ok(ReturnSuccess::Value(f.into())),
-                            Err(e) => yield Err(e)
-                        }
+    let params = DirBuilder {
+        tag: tag.clone(),
+        min: min_size,
+        deref,
+        exclude,
+        all,
+    };
+
+    let inp = futures::stream::iter(paths);
+
+    Ok(inp
+        .flat_map(move |path| match path {
+            Ok(p) => {
+                let mut output = vec![];
+                if p.is_dir() {
+                    output.push(Ok(ReturnSuccess::Value(
+                        DirInfo::new(p, &params, max_depth, ctrl_c.clone()).into(),
+                    )));
+                } else {
+                    for v in FileInfo::new(p, deref, tag.clone()).into_iter() {
+                        output.push(Ok(ReturnSuccess::Value(v.into())));
                     }
                 }
-                Err(e) => yield Err(e),
+                futures::stream::iter(output)
             }
-        }
-    };
-    Ok(stream.to_output_stream())
+            Err(e) => futures::stream::iter(vec![Err(e)]),
+        })
+        .interruptible(ctrl_c_copy)
+        .to_output_stream())
 }
 
-struct DirBuilder {
+pub struct DirBuilder {
     tag: Tag,
     min: Option<u64>,
     deref: bool,
-    ex: Option<Pattern>,
+    exclude: Option<Pattern>,
     all: bool,
 }
 
-struct DirInfo {
+impl DirBuilder {
+    pub fn new(
+        tag: Tag,
+        min: Option<u64>,
+        deref: bool,
+        exclude: Option<Pattern>,
+        all: bool,
+    ) -> DirBuilder {
+        DirBuilder {
+            tag,
+            min,
+            deref,
+            exclude,
+            all,
+        }
+    }
+}
+
+pub struct DirInfo {
     dirs: Vec<DirInfo>,
     files: Vec<FileInfo>,
     errors: Vec<ShellError>,
@@ -225,7 +230,12 @@ impl FileInfo {
 }
 
 impl DirInfo {
-    fn new(path: impl Into<PathBuf>, params: &DirBuilder, depth: Option<u64>) -> Self {
+    pub fn new(
+        path: impl Into<PathBuf>,
+        params: &DirBuilder,
+        depth: Option<u64>,
+        ctrl_c: Arc<AtomicBool>,
+    ) -> Self {
         let path = path.into();
 
         let mut s = Self {
@@ -241,17 +251,19 @@ impl DirInfo {
         match std::fs::read_dir(&s.path) {
             Ok(d) => {
                 for f in d {
+                    if ctrl_c.load(Ordering::SeqCst) {
+                        break;
+                    }
+
                     match f {
                         Ok(i) => match i.file_type() {
                             Ok(t) if t.is_dir() => {
-                                s = s.add_dir(i.path(), depth, &params);
+                                s = s.add_dir(i.path(), depth, &params, ctrl_c.clone())
                             }
-                            Ok(_t) => {
-                                s = s.add_file(i.path(), &params);
-                            }
-                            Err(e) => s = s.add_error(ShellError::from(e)),
+                            Ok(_t) => s = s.add_file(i.path(), &params),
+                            Err(e) => s = s.add_error(e.into()),
                         },
-                        Err(e) => s = s.add_error(ShellError::from(e)),
+                        Err(e) => s = s.add_error(e.into()),
                     }
                 }
             }
@@ -265,6 +277,7 @@ impl DirInfo {
         path: impl Into<PathBuf>,
         mut depth: Option<u64>,
         params: &DirBuilder,
+        ctrl_c: Arc<AtomicBool>,
     ) -> Self {
         if let Some(current) = depth {
             if let Some(new) = current.checked_sub(1) {
@@ -274,7 +287,7 @@ impl DirInfo {
             }
         }
 
-        let d = DirInfo::new(path, &params, depth);
+        let d = DirInfo::new(path, &params, depth, ctrl_c);
         self.size += d.size;
         self.blocks += d.blocks;
         self.dirs.push(d);
@@ -283,8 +296,11 @@ impl DirInfo {
 
     fn add_file(mut self, f: impl Into<PathBuf>, params: &DirBuilder) -> Self {
         let f = f.into();
-        let ex = params.ex.as_ref().map_or(false, |x| x.matches_path(&f));
-        if !ex {
+        let include = params
+            .exclude
+            .as_ref()
+            .map_or(true, |x| !x.matches_path(&f));
+        if include {
             match FileInfo::new(f, params.deref, self.tag.clone()) {
                 Ok(file) => {
                     let inc = params.min.map_or(true, |s| file.size >= s);
@@ -306,6 +322,10 @@ impl DirInfo {
         self.errors.push(e);
         self
     }
+
+    pub fn get_size(&self) -> u64 {
+        self.size
+    }
 }
 
 fn glob_err_into(e: GlobError) -> ShellError {
@@ -313,55 +333,51 @@ fn glob_err_into(e: GlobError) -> ShellError {
     ShellError::from(e)
 }
 
+fn value_from_vec<V>(vec: Vec<V>, tag: &Tag) -> Value
+where
+    V: Into<Value>,
+{
+    if vec.is_empty() {
+        UntaggedValue::nothing()
+    } else {
+        let values = vec.into_iter().map(Into::into).collect::<Vec<Value>>();
+        UntaggedValue::Table(values)
+    }
+    .into_value(tag)
+}
+
 impl From<DirInfo> for Value {
     fn from(d: DirInfo) -> Self {
         let mut r: IndexMap<String, Value> = IndexMap::new();
+
         r.insert(
             "path".to_string(),
-            UntaggedValue::path(d.path).retag(d.tag.clone()),
+            UntaggedValue::path(d.path).into_value(&d.tag),
         );
+
         r.insert(
             "apparent".to_string(),
-            UntaggedValue::bytes(d.size).retag(d.tag.clone()),
+            UntaggedValue::filesize(d.size).into_value(&d.tag),
         );
+
         r.insert(
             "physical".to_string(),
-            UntaggedValue::bytes(d.blocks).retag(d.tag.clone()),
+            UntaggedValue::filesize(d.blocks).into_value(&d.tag),
         );
-        if !d.files.is_empty() {
-            let v = Value {
-                value: UntaggedValue::Table(
-                    d.files
-                        .into_iter()
-                        .map(move |f| f.into())
-                        .collect::<Vec<Value>>(),
-                ),
-                tag: d.tag.clone(),
-            };
-            r.insert("files".to_string(), v);
-        }
-        if !d.dirs.is_empty() {
-            let v = Value {
-                value: UntaggedValue::Table(
-                    d.dirs
-                        .into_iter()
-                        .map(move |d| d.into())
-                        .collect::<Vec<Value>>(),
-                ),
-                tag: d.tag.clone(),
-            };
-            r.insert("directories".to_string(), v);
-        }
+
+        r.insert("directories".to_string(), value_from_vec(d.dirs, &d.tag));
+
+        r.insert("files".to_string(), value_from_vec(d.files, &d.tag));
+
         if !d.errors.is_empty() {
-            let v = Value {
-                value: UntaggedValue::Table(
-                    d.errors
-                        .into_iter()
-                        .map(move |e| UntaggedValue::Error(e).into_untagged_value())
-                        .collect::<Vec<Value>>(),
-                ),
-                tag: d.tag.clone(),
-            };
+            let v = UntaggedValue::Table(
+                d.errors
+                    .into_iter()
+                    .map(move |e| UntaggedValue::Error(e).into_untagged_value())
+                    .collect::<Vec<Value>>(),
+            )
+            .into_value(&d.tag);
+
             r.insert("errors".to_string(), v);
         }
 
@@ -375,22 +391,48 @@ impl From<DirInfo> for Value {
 impl From<FileInfo> for Value {
     fn from(f: FileInfo) -> Self {
         let mut r: IndexMap<String, Value> = IndexMap::new();
+
         r.insert(
             "path".to_string(),
-            UntaggedValue::path(f.path).retag(f.tag.clone()),
+            UntaggedValue::path(f.path).into_value(&f.tag),
         );
+
         r.insert(
             "apparent".to_string(),
-            UntaggedValue::bytes(f.size).retag(f.tag.clone()),
+            UntaggedValue::filesize(f.size).into_value(&f.tag),
         );
-        let b = match f.blocks {
-            Some(k) => UntaggedValue::bytes(k).retag(f.tag.clone()),
-            None => UntaggedValue::nothing().retag(f.tag.clone()),
-        };
+
+        let b = f
+            .blocks
+            .map(UntaggedValue::filesize)
+            .unwrap_or_else(UntaggedValue::nothing)
+            .into_value(&f.tag);
+
         r.insert("physical".to_string(), b);
-        Value {
-            value: UntaggedValue::row(r),
-            tag: f.tag,
-        }
+
+        r.insert(
+            "directories".to_string(),
+            UntaggedValue::nothing().into_value(&f.tag),
+        );
+
+        r.insert(
+            "files".to_string(),
+            UntaggedValue::nothing().into_value(&f.tag),
+        );
+
+        UntaggedValue::row(r).into_value(&f.tag)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Du;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Du {})?)
     }
 }

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

@@ -0,0 +1,175 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::classified::block::run_block;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+
+use futures::stream::once;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::Block, hir::Expression, hir::SpannedExpression, hir::Synthetic, Scope, Signature,
+    SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+
+pub struct Each;
+
+#[derive(Deserialize)]
+pub struct EachArgs {
+    block: Block,
+    numbered: Tagged<bool>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Each {
+    fn name(&self) -> &str {
+        "each"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("each")
+            .required("block", SyntaxShape::Block, "the block to run on each row")
+            .switch(
+                "numbered",
+                "returned a numbered item ($it.index and $it.item)",
+                Some('n'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Run a block on each row of the table."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        each(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Echo the sum of each row",
+                example: "echo [[1 2] [3 4]] | each { echo $it | math sum }",
+                result: None,
+            },
+            Example {
+                description: "Echo the square of each integer",
+                example: "echo [1 2 3] | each { echo $(= $it * $it) }",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(4).into(),
+                    UntaggedValue::int(9).into(),
+                ]),
+            },
+            Example {
+                description: "Number each item and echo a message",
+                example:
+                    "echo ['bob' 'fred'] | each --numbered { echo `{{$it.index}} is {{$it.item}}` }",
+                result: Some(vec![Value::from("0 is bob"), Value::from("1 is fred")]),
+            },
+        ]
+    }
+}
+
+fn is_expanded_it_usage(head: &SpannedExpression) -> bool {
+    matches!(&*head, SpannedExpression {
+        expr: Expression::Synthetic(Synthetic::String(s)),
+        ..
+    } if s == "expanded-each")
+}
+
+pub async fn process_row(
+    block: Arc<Block>,
+    scope: Arc<Scope>,
+    head: Arc<Box<SpannedExpression>>,
+    mut context: Arc<EvaluationContext>,
+    input: Value,
+) -> Result<OutputStream, ShellError> {
+    let input_clone = input.clone();
+    let input_stream = if is_expanded_it_usage(&head) {
+        InputStream::empty()
+    } else {
+        once(async { Ok(input_clone) }).to_input_stream()
+    };
+    Ok(run_block(
+        &block,
+        Arc::make_mut(&mut context),
+        input_stream,
+        Scope::append_it(scope, input),
+    )
+    .await?
+    .to_output_stream())
+}
+
+pub(crate) fn make_indexed_item(index: usize, item: Value) -> Value {
+    let mut dict = TaggedDictBuilder::new(item.tag());
+    dict.insert_untagged("index", UntaggedValue::int(index));
+    dict.insert_value("item", item);
+
+    dict.into_value()
+}
+
+async fn each(
+    raw_args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let head = Arc::new(raw_args.call_info.args.head.clone());
+    let scope = raw_args.call_info.scope.clone();
+    let context = Arc::new(EvaluationContext::from_raw(&raw_args, &registry));
+    let (each_args, input): (EachArgs, _) = raw_args.process(&registry).await?;
+    let block = Arc::new(each_args.block);
+
+    if each_args.numbered.item {
+        Ok(input
+            .enumerate()
+            .then(move |input| {
+                let block = block.clone();
+                let scope = scope.clone();
+                let head = head.clone();
+                let context = context.clone();
+                let row = make_indexed_item(input.0, input.1);
+
+                async {
+                    match process_row(block, scope, head, context, row).await {
+                        Ok(s) => s,
+                        Err(e) => OutputStream::one(Err(e)),
+                    }
+                }
+            })
+            .flatten()
+            .to_output_stream())
+    } else {
+        Ok(input
+            .then(move |input| {
+                let block = block.clone();
+                let scope = scope.clone();
+                let head = head.clone();
+                let context = context.clone();
+
+                async {
+                    match process_row(block, scope, head, context, input).await {
+                        Ok(s) => s,
+                        Err(e) => OutputStream::one(Err(e)),
+                    }
+                }
+            })
+            .flatten()
+            .to_output_stream())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Each;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Each {})?)
+    }
+}

crates/nu-cli/src/commands/each/group.rs

@@ -0,0 +1,134 @@
+use crate::commands::each::process_row;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::Block, hir::SpannedExpression, ReturnSuccess, Scope, Signature, SyntaxShape,
+    UntaggedValue, Value,
+};
+use nu_source::Tagged;
+use serde::Deserialize;
+
+pub struct EachGroup;
+
+#[derive(Deserialize)]
+pub struct EachGroupArgs {
+    group_size: Tagged<usize>,
+    block: Block,
+    //numbered: Tagged<bool>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for EachGroup {
+    fn name(&self) -> &str {
+        "each group"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("each group")
+            .required("group_size", SyntaxShape::Int, "the size of each group")
+            .required(
+                "block",
+                SyntaxShape::Block,
+                "the block to run on each group",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block on groups of `group_size` rows of a table at a time."
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Echo the sum of each pair",
+            example: "echo [1 2 3 4] | each group 2 { echo $it | math sum }",
+            result: None,
+        }]
+    }
+
+    async fn run(
+        &self,
+        raw_args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let registry = registry.clone();
+        let head = Arc::new(raw_args.call_info.args.head.clone());
+        let scope = raw_args.call_info.scope.clone();
+        let context = Arc::new(EvaluationContext::from_raw(&raw_args, &registry));
+        let (each_args, input): (EachGroupArgs, _) = raw_args.process(&registry).await?;
+        let block = Arc::new(each_args.block);
+
+        Ok(input
+            .chunks(each_args.group_size.item)
+            .then(move |input| {
+                run_block_on_vec(
+                    input,
+                    block.clone(),
+                    scope.clone(),
+                    head.clone(),
+                    context.clone(),
+                )
+            })
+            .flatten()
+            .to_output_stream())
+    }
+}
+
+pub(crate) fn run_block_on_vec(
+    input: Vec<Value>,
+    block: Arc<Block>,
+    scope: Arc<Scope>,
+    head: Arc<Box<SpannedExpression>>,
+    context: Arc<EvaluationContext>,
+) -> impl Future<Output = OutputStream> {
+    let value = Value {
+        value: UntaggedValue::Table(input),
+        tag: Tag::unknown(),
+    };
+
+    async {
+        match process_row(block, scope, head, context, value).await {
+            Ok(s) => {
+                // We need to handle this differently depending on whether process_row
+                // returned just 1 value or if it returned multiple as a stream.
+                let vec = s.collect::<Vec<_>>().await;
+
+                // If it returned just one value, just take that value
+                if vec.len() == 1 {
+                    return OutputStream::one(vec.into_iter().next().expect(
+                        "This should be impossible, we just checked that vec.len() == 1.",
+                    ));
+                }
+
+                // If it returned multiple values, we need to put them into a table and
+                // return that.
+                let result = vec.into_iter().collect::<Result<Vec<ReturnSuccess>, _>>();
+                let result_table = match result {
+                    Ok(t) => t,
+                    Err(e) => return OutputStream::one(Err(e)),
+                };
+
+                let table = result_table
+                    .into_iter()
+                    .filter_map(|x| x.raw_value())
+                    .collect();
+
+                OutputStream::one(Ok(ReturnSuccess::Value(UntaggedValue::Table(table).into())))
+            }
+            Err(e) => OutputStream::one(Err(e)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EachGroup;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(EachGroup {})?)
+    }
+}

crates/nu-cli/src/commands/each/mod.rs

@@ -0,0 +1,9 @@
+pub mod command;
+pub mod group;
+pub mod window;
+
+pub(crate) use command::make_indexed_item;
+pub use command::process_row;
+pub use command::Each;
+pub use group::EachGroup;
+pub use window::EachWindow;

crates/nu-cli/src/commands/each/window.rs

@@ -0,0 +1,114 @@
+use crate::commands::each::group::run_block_on_vec;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+//use itertools::Itertools;
+use nu_errors::ShellError;
+use nu_protocol::{hir::Block, Primitive, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+use serde::Deserialize;
+
+pub struct EachWindow;
+
+#[derive(Deserialize)]
+pub struct EachWindowArgs {
+    window_size: Tagged<usize>,
+    block: Block,
+    stride: Option<Tagged<usize>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for EachWindow {
+    fn name(&self) -> &str {
+        "each window"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("each window")
+            .required("window_size", SyntaxShape::Int, "the size of each window")
+            .named(
+                "stride",
+                SyntaxShape::Int,
+                "the number of rows to slide over between windows",
+                Some('s'),
+            )
+            .required(
+                "block",
+                SyntaxShape::Block,
+                "the block to run on each group",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block on sliding windows of `window_size` rows of a table at a time."
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Echo the sum of each window",
+            example: "echo [1 2 3 4] | each window 2 { echo $it | math sum }",
+            result: None,
+        }]
+    }
+
+    async fn run(
+        &self,
+        raw_args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let registry = registry.clone();
+        let head = Arc::new(raw_args.call_info.args.head.clone());
+        let scope = raw_args.call_info.scope.clone();
+        let context = Arc::new(EvaluationContext::from_raw(&raw_args, &registry));
+        let (each_args, mut input): (EachWindowArgs, _) = raw_args.process(&registry).await?;
+        let block = Arc::new(each_args.block);
+
+        let mut window: Vec<_> = input
+            .by_ref()
+            .take(*each_args.window_size - 1)
+            .collect::<Vec<_>>()
+            .await;
+
+        // `window` must start with dummy values, which will be removed on the first iteration
+        let stride = each_args.stride.map(|x| *x).unwrap_or(1);
+        window.insert(0, UntaggedValue::Primitive(Primitive::Nothing).into());
+
+        Ok(input
+            .enumerate()
+            .then(move |(i, input)| {
+                // This would probably be more efficient if `last` was a VecDeque
+                // But we can't have that because it needs to be put into a Table
+                window.remove(0);
+                window.push(input);
+
+                let block = block.clone();
+                let scope = scope.clone();
+                let head = head.clone();
+                let context = context.clone();
+                let local_window = window.clone();
+
+                async move {
+                    if i % stride == 0 {
+                        Some(run_block_on_vec(local_window, block, scope, head, context).await)
+                    } else {
+                        None
+                    }
+                }
+            })
+            .filter_map(|x| async { x })
+            .flatten()
+            .to_output_stream())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EachWindow;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(EachWindow {})?)
+    }
+}

crates/nu-cli/src/commands/echo.rs

@@ -0,0 +1,173 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::hir::Operator;
+use nu_protocol::{
+    Primitive, Range, RangeInclusion, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+
+pub struct Echo;
+
+#[derive(Deserialize)]
+pub struct EchoArgs {
+    pub rest: Vec<Value>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Echo {
+    fn name(&self) -> &str {
+        "echo"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("echo").rest(SyntaxShape::Any, "the values to echo")
+    }
+
+    fn usage(&self) -> &str {
+        "Echo the arguments back to the user."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        echo(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Put a hello message in the pipeline",
+                example: "echo 'hello'",
+                result: Some(vec![Value::from("hello")]),
+            },
+            Example {
+                description: "Print the value of the special '$nu' variable",
+                example: "echo $nu",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn echo(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let (args, _): (EchoArgs, _) = args.process(&registry).await?;
+
+    let stream = args.rest.into_iter().map(|i| match i.as_string() {
+        Ok(s) => OutputStream::one(Ok(ReturnSuccess::Value(
+            UntaggedValue::string(s).into_value(i.tag.clone()),
+        ))),
+        _ => match i {
+            Value {
+                value: UntaggedValue::Table(table),
+                ..
+            } => futures::stream::iter(table.into_iter().map(ReturnSuccess::value))
+                .to_output_stream(),
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Range(range)),
+                tag,
+            } => futures::stream::iter(RangeIterator::new(*range, tag)).to_output_stream(),
+            _ => OutputStream::one(Ok(ReturnSuccess::Value(i.clone()))),
+        },
+    });
+
+    Ok(futures::stream::iter(stream).flatten().to_output_stream())
+}
+
+struct RangeIterator {
+    curr: Primitive,
+    end: Primitive,
+    tag: Tag,
+    is_end_inclusive: bool,
+}
+
+impl RangeIterator {
+    pub fn new(range: Range, tag: Tag) -> RangeIterator {
+        let start = match range.from.0.item {
+            Primitive::Nothing => Primitive::Int(0.into()),
+            x => x,
+        };
+
+        RangeIterator {
+            curr: start,
+            end: range.to.0.item,
+            tag,
+            is_end_inclusive: matches!(range.to.1, RangeInclusion::Inclusive),
+        }
+    }
+}
+
+impl Iterator for RangeIterator {
+    type Item = Result<ReturnSuccess, ShellError>;
+    fn next(&mut self) -> Option<Self::Item> {
+        let ordering = if self.end == Primitive::Nothing {
+            Ordering::Less
+        } else {
+            let result =
+                nu_data::base::coerce_compare_primitive(&self.curr, &self.end).map_err(|_| {
+                    ShellError::labeled_error(
+                        "Cannot create range",
+                        "unsupported range",
+                        self.tag.span,
+                    )
+                });
+
+            if let Err(result) = result {
+                return Some(Err(result));
+            }
+
+            let result = result
+                .expect("Internal error: the error case was already protected, but that failed");
+
+            result.compare()
+        };
+
+        use std::cmp::Ordering;
+
+        if (ordering == Ordering::Less) || (self.is_end_inclusive && ordering == Ordering::Equal) {
+            let output = UntaggedValue::Primitive(self.curr.clone()).into_value(self.tag.clone());
+
+            let next_value = nu_data::value::compute_values(
+                Operator::Plus,
+                &UntaggedValue::Primitive(self.curr.clone()),
+                &UntaggedValue::int(1),
+            );
+
+            self.curr = match next_value {
+                Ok(result) => match result {
+                    UntaggedValue::Primitive(p) => p,
+                    _ => {
+                        return Some(Err(ShellError::unimplemented(
+                            "Internal error: expected a primitive result from increment",
+                        )));
+                    }
+                },
+                Err((left_type, right_type)) => {
+                    return Some(Err(ShellError::coerce_error(
+                        left_type.spanned(self.tag.span),
+                        right_type.spanned(self.tag.span),
+                    )));
+                }
+            };
+            Some(ReturnSuccess::value(output))
+        } else {
+            // TODO: add inclusive/exclusive ranges
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Echo;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Echo {})?)
+    }
+}

crates/nu-cli/src/commands/empty.rs

@@ -0,0 +1,288 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::classified::block::run_block;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::Block, ColumnPath, Primitive, ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue,
+    Value,
+};
+use nu_source::Tagged;
+use nu_value_ext::{as_string, ValueExt};
+
+use futures::stream::once;
+use indexmap::indexmap;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    rest: Vec<Value>,
+}
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "empty?"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("empty?").rest(
+            SyntaxShape::Any,
+            "the names of the columns to check emptiness. Pass an optional block to replace if empty",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Check for empty values"
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        is_empty(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Check if a value is empty",
+                example: "echo '' | empty?",
+                result: Some(vec![UntaggedValue::boolean(true).into()]),
+            },
+            Example {
+                description: "more than one column",
+                example: "echo [[meal size]; [arepa small] [taco '']] | empty? meal size",
+                result: Some(
+                    vec![
+                        UntaggedValue::row(indexmap! {
+                                "meal".to_string() => Value::from(false),
+                                "size".to_string() => Value::from(false),
+                        })
+                        .into(),
+                        UntaggedValue::row(indexmap! {
+                                "meal".to_string() => Value::from(false),
+                                "size".to_string() => Value::from(true),
+                        })
+                        .into(),
+                    ],
+                ),
+            },Example {
+                description: "use a block if setting the empty cell contents is wanted",
+                example: "echo [[2020/04/16 2020/07/10 2020/11/16]; ['' [27] [37]]] | empty? 2020/04/16 { = [33 37] }",
+                result: Some(
+                    vec![
+                        UntaggedValue::row(indexmap! {
+                                "2020/04/16".to_string() => UntaggedValue::table(&[UntaggedValue::int(33).into(), UntaggedValue::int(37).into()]).into(),
+                                "2020/07/10".to_string() => UntaggedValue::table(&[UntaggedValue::int(27).into()]).into(),
+                                "2020/11/16".to_string() => UntaggedValue::table(&[UntaggedValue::int(37).into()]).into(),
+                        })
+                        .into(),
+                    ],
+                ),
+            },
+        ]
+    }
+}
+
+async fn is_empty(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let name_tag = Arc::new(args.call_info.name_tag.clone());
+    let context = Arc::new(EvaluationContext::from_raw(&args, &registry));
+    let scope = args.call_info.scope.clone();
+    let (Arguments { rest }, input) = args.process(&registry).await?;
+    let (columns, default_block): (Vec<ColumnPath>, Option<Block>) = arguments(rest)?;
+    let default_block = Arc::new(default_block);
+
+    if input.is_empty() {
+        let stream = futures::stream::iter(vec![
+            UntaggedValue::Primitive(Primitive::Nothing).into_value(tag)
+        ]);
+
+        return Ok(InputStream::from_stream(stream)
+            .then(move |input| {
+                let tag = name_tag.clone();
+                let scope = scope.clone();
+                let context = context.clone();
+                let block = default_block.clone();
+                let columns = vec![];
+
+                async {
+                    match process_row(scope, context, input, block, columns, tag).await {
+                        Ok(s) => s,
+                        Err(e) => OutputStream::one(Err(e)),
+                    }
+                }
+            })
+            .flatten()
+            .to_output_stream());
+    }
+
+    Ok(input
+        .then(move |input| {
+            let tag = name_tag.clone();
+            let scope = scope.clone();
+            let context = context.clone();
+            let block = default_block.clone();
+            let columns = columns.clone();
+
+            async {
+                match process_row(scope, context, input, block, columns, tag).await {
+                    Ok(s) => s,
+                    Err(e) => OutputStream::one(Err(e)),
+                }
+            }
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+fn arguments(rest: Vec<Value>) -> Result<(Vec<ColumnPath>, Option<Block>), ShellError> {
+    let mut rest = rest;
+    let mut columns = vec![];
+    let mut default = None;
+
+    let last_argument = rest.pop();
+
+    match last_argument {
+        Some(Value {
+            value: UntaggedValue::Block(call),
+            ..
+        }) => default = Some(call),
+        Some(other) => {
+            let Tagged { item: path, .. } = other.as_column_path()?;
+
+            columns = vec![path];
+        }
+        None => {}
+    };
+
+    for argument in rest {
+        let Tagged { item: path, .. } = argument.as_column_path()?;
+
+        columns.push(path);
+    }
+
+    Ok((columns, default))
+}
+
+async fn process_row(
+    scope: Arc<Scope>,
+    mut context: Arc<EvaluationContext>,
+    input: Value,
+    default_block: Arc<Option<Block>>,
+    column_paths: Vec<ColumnPath>,
+    tag: Arc<Tag>,
+) -> Result<OutputStream, ShellError> {
+    let _tag = &*tag;
+    let mut out = Arc::new(None);
+    let results = Arc::make_mut(&mut out);
+
+    if let Some(default_block) = &*default_block {
+        let for_block = input.clone();
+        let input_stream = once(async { Ok(for_block) }).to_input_stream();
+
+        let scope = Scope::append_it(scope, input.clone());
+
+        let mut stream = run_block(
+            &default_block,
+            Arc::make_mut(&mut context),
+            input_stream,
+            scope,
+        )
+        .await?;
+
+        *results = Some({
+            let values = stream.drain_vec().await;
+
+            let errors = context.get_errors();
+
+            if let Some(error) = errors.first() {
+                return Err(error.clone());
+            }
+
+            if values.len() == 1 {
+                let value = values
+                    .get(0)
+                    .ok_or_else(|| ShellError::unexpected("No value."))?;
+
+                Value {
+                    value: value.value.clone(),
+                    tag: input.tag.clone(),
+                }
+            } else if values.is_empty() {
+                UntaggedValue::nothing().into_value(&input.tag)
+            } else {
+                UntaggedValue::table(&values).into_value(&input.tag)
+            }
+        });
+    }
+
+    match input {
+        Value {
+            value: UntaggedValue::Row(ref r),
+            ref tag,
+        } => {
+            if column_paths.is_empty() {
+                Ok(OutputStream::one(ReturnSuccess::value({
+                    let is_empty = input.is_empty();
+
+                    if default_block.is_some() {
+                        if is_empty {
+                            results
+                                .clone()
+                                .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(tag))
+                        } else {
+                            input.clone()
+                        }
+                    } else {
+                        UntaggedValue::boolean(is_empty).into_value(tag)
+                    }
+                })))
+            } else {
+                let mut obj = input.clone();
+
+                for column in column_paths.clone() {
+                    let path = UntaggedValue::Primitive(Primitive::ColumnPath(column.clone()))
+                        .into_value(tag);
+                    let data = r.get_data(&as_string(&path)?).borrow().clone();
+                    let is_empty = data.is_empty();
+
+                    let default = if default_block.is_some() {
+                        if is_empty {
+                            results
+                                .clone()
+                                .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(tag))
+                        } else {
+                            data.clone()
+                        }
+                    } else {
+                        UntaggedValue::boolean(is_empty).into_value(tag)
+                    };
+
+                    if let Ok(value) =
+                        obj.swap_data_by_column_path(&column, Box::new(move |_| Ok(default)))
+                    {
+                        obj = value;
+                    }
+                }
+
+                Ok(OutputStream::one(ReturnSuccess::value(obj)))
+            }
+        }
+        other => Ok(OutputStream::one(ReturnSuccess::value({
+            if other.is_empty() {
+                results
+                    .clone()
+                    .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(other.tag))
+            } else {
+                UntaggedValue::boolean(false).into_value(other.tag)
+            }
+        }))),
+    }
+}

crates/nu-cli/src/commands/enter.rs

@@ -0,0 +1,202 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::UnevaluatedCallInfo;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::hir::ExternalRedirection;
+use nu_protocol::{
+    CommandAction, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+use std::path::PathBuf;
+
+pub struct Enter;
+
+#[derive(Deserialize)]
+pub struct EnterArgs {
+    location: Tagged<PathBuf>,
+    encoding: Option<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Enter {
+    fn name(&self) -> &str {
+        "enter"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("enter")
+            .required(
+                "location",
+                SyntaxShape::Path,
+                "the location to create a new shell from",
+            )
+            .named(
+                "encoding",
+                SyntaxShape::String,
+                "encoding to use to open file",
+                Some('e'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        r#"Create a new shell and begin at this path.
+        
+Multiple encodings are supported for reading text files by using
+the '--encoding <encoding>' parameter. Here is an example of a few:
+big5, euc-jp, euc-kr, gbk, iso-8859-1, utf-16, cp1252, latin5
+
+For a more complete list of encodings please refer to the encoding_rs
+documentation link at https://docs.rs/encoding_rs/0.8.23/encoding_rs/#statics"#
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        enter(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Enter a path as a new shell",
+                example: "enter ../projectB",
+                result: None,
+            },
+            Example {
+                description: "Enter a file as a new shell",
+                example: "enter package.json",
+                result: None,
+            },
+            Example {
+                description: "Enters file with iso-8859-1 encoding",
+                example: "enter file.csv --encoding iso-8859-1",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn enter(
+    raw_args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let scope = raw_args.call_info.scope.clone();
+    let shell_manager = raw_args.shell_manager.clone();
+    let head = raw_args.call_info.args.head.clone();
+    let ctrl_c = raw_args.ctrl_c.clone();
+    let current_errors = raw_args.current_errors.clone();
+    let host = raw_args.host.clone();
+    let tag = raw_args.call_info.name_tag.clone();
+    let (EnterArgs { location, encoding }, _) = raw_args.process(&registry).await?;
+    let location_string = location.display().to_string();
+    let location_clone = location_string.clone();
+
+    if location_string.starts_with("help") {
+        let spec = location_string.split(':').collect::<Vec<&str>>();
+
+        if spec.len() == 2 {
+            let (_, command) = (spec[0], spec[1]);
+
+            if registry.has(command) {
+                return Ok(OutputStream::one(ReturnSuccess::action(
+                    CommandAction::EnterHelpShell(
+                        UntaggedValue::string(command).into_value(Tag::unknown()),
+                    ),
+                )));
+            }
+        }
+        Ok(OutputStream::one(ReturnSuccess::action(
+            CommandAction::EnterHelpShell(UntaggedValue::nothing().into_value(Tag::unknown())),
+        )))
+    } else if location.is_dir() {
+        Ok(OutputStream::one(ReturnSuccess::action(
+            CommandAction::EnterShell(location_clone),
+        )))
+    } else {
+        // If it's a file, attempt to open the file as a value and enter it
+        let cwd = shell_manager.path();
+
+        let full_path = std::path::PathBuf::from(cwd);
+
+        let (file_extension, tagged_contents) = crate::commands::open::fetch(
+            &full_path,
+            &PathBuf::from(location_clone),
+            tag.span,
+            encoding,
+        )
+        .await?;
+
+        match tagged_contents.value {
+            UntaggedValue::Primitive(Primitive::String(_)) => {
+                if let Some(extension) = file_extension {
+                    let command_name = format!("from {}", extension);
+                    if let Some(converter) = registry.get_command(&command_name) {
+                        let new_args = RawCommandArgs {
+                            host,
+                            ctrl_c,
+                            current_errors,
+                            shell_manager,
+                            call_info: UnevaluatedCallInfo {
+                                args: nu_protocol::hir::Call {
+                                    head,
+                                    positional: None,
+                                    named: None,
+                                    span: Span::unknown(),
+                                    external_redirection: ExternalRedirection::Stdout,
+                                },
+                                name_tag: tag.clone(),
+                                scope: scope.clone(),
+                            },
+                        };
+                        let tag = tagged_contents.tag.clone();
+                        let mut result = converter
+                            .run(new_args.with_input(vec![tagged_contents]), &registry)
+                            .await?;
+                        let result_vec: Vec<Result<ReturnSuccess, ShellError>> =
+                            result.drain_vec().await;
+                        Ok(futures::stream::iter(result_vec.into_iter().map(
+                            move |res| match res {
+                                Ok(ReturnSuccess::Value(Value { value, .. })) => Ok(
+                                    ReturnSuccess::Action(CommandAction::EnterValueShell(Value {
+                                        value,
+                                        tag: tag.clone(),
+                                    })),
+                                ),
+                                x => x,
+                            },
+                        ))
+                        .to_output_stream())
+                    } else {
+                        Ok(OutputStream::one(ReturnSuccess::action(
+                            CommandAction::EnterValueShell(tagged_contents),
+                        )))
+                    }
+                } else {
+                    Ok(OutputStream::one(ReturnSuccess::action(
+                        CommandAction::EnterValueShell(tagged_contents),
+                    )))
+                }
+            }
+            _ => Ok(OutputStream::one(ReturnSuccess::action(
+                CommandAction::EnterValueShell(tagged_contents),
+            ))),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Enter;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Enter {})?)
+    }
+}

crates/nu-cli/src/commands/every.rs

@@ -0,0 +1,104 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct Every;
+
+#[derive(Deserialize)]
+pub struct EveryArgs {
+    stride: Tagged<u64>,
+    skip: Tagged<bool>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Every {
+    fn name(&self) -> &str {
+        "every"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .required(
+                "stride",
+                SyntaxShape::Int,
+                "how many rows to skip between (and including) each row returned",
+            )
+            .switch(
+                "skip",
+                "skip the rows that would be returned, instead of selecting them",
+                Some('s'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Show (or skip) every n-th row, starting from the first one."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        every(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get every second row",
+                example: "echo [1 2 3 4 5] | every 2",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(3).into(),
+                    UntaggedValue::int(5).into(),
+                ]),
+            },
+            Example {
+                description: "Skip every second row",
+                example: "echo [1 2 3 4 5] | every 2 --skip",
+                result: Some(vec![
+                    UntaggedValue::int(2).into(),
+                    UntaggedValue::int(4).into(),
+                ]),
+            },
+        ]
+    }
+}
+
+async fn every(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let (EveryArgs { stride, skip }, input) = args.process(&registry).await?;
+
+    let stride = stride.item;
+    let skip = skip.item;
+
+    Ok(input
+        .enumerate()
+        .filter_map(move |(i, value)| async move {
+            let stride_desired = if stride < 1 { 1 } else { stride } as usize;
+            let should_include = skip == (i % stride_desired != 0);
+
+            if should_include {
+                Some(ReturnSuccess::value(value))
+            } else {
+                None
+            }
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Every;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Every {})?)
+    }
+}

crates/nu-cli/src/commands/exec.rs

@@ -0,0 +1,87 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape};
+use nu_source::Tagged;
+use std::path::PathBuf;
+
+pub struct Exec;
+
+#[derive(Deserialize)]
+pub struct ExecArgs {
+    pub command: Tagged<PathBuf>,
+    pub rest: Vec<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Exec {
+    fn name(&self) -> &str {
+        "exec"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("exec")
+            .required("command", SyntaxShape::Path, "the command to execute")
+            .rest(SyntaxShape::Pattern, "any additional arguments for command")
+    }
+
+    fn usage(&self) -> &str {
+        "Execute command"
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        exec(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Execute 'ps aux'",
+                example: "exec ps aux",
+                result: None,
+            },
+            Example {
+                description: "Execute 'nautilus'",
+                example: "exec nautilus",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(unix)]
+async fn exec(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    use std::os::unix::process::CommandExt;
+    use std::process::Command;
+
+    let registry = registry.clone();
+    let name = args.call_info.name_tag.clone();
+    let (args, _): (ExecArgs, _) = args.process(&registry).await?;
+
+    let mut command = Command::new(args.command.item);
+    for tagged_arg in args.rest {
+        command.arg(tagged_arg.item);
+    }
+
+    let err = command.exec(); // this replaces our process, should not return
+
+    Err(ShellError::labeled_error(
+        "Error on exec",
+        format!("{}", err),
+        &name,
+    ))
+}
+
+#[cfg(not(unix))]
+async fn exec(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    Err(ShellError::labeled_error(
+        "Error on exec",
+        "exec is not supported on your platform",
+        &args.call_info.name_tag,
+    ))
+}

crates/nu-cli/src/commands/exit.rs

@@ -0,0 +1,74 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::command::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{CommandAction, ReturnSuccess, Signature};
+
+pub struct Exit;
+
+#[async_trait]
+impl WholeStreamCommand for Exit {
+    fn name(&self) -> &str {
+        "exit"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("exit").switch("now", "exit out of the shell immediately", Some('n'))
+    }
+
+    fn usage(&self) -> &str {
+        "Exit the current shell (or all shells)"
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        exit(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Exit the current shell",
+                example: "exit",
+                result: None,
+            },
+            Example {
+                description: "Exit all shells (exiting Nu)",
+                example: "exit --now",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn exit(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let args = args.evaluate_once(&registry).await?;
+
+    let command_action = if args.call_info.args.has("now") {
+        CommandAction::Exit
+    } else {
+        CommandAction::LeaveShell
+    };
+
+    Ok(OutputStream::one(ReturnSuccess::action(command_action)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Exit;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Exit {})?)
+    }
+}

crates/nu-cli/src/commands/first.rs

@@ -0,0 +1,83 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct First;
+
+#[derive(Deserialize)]
+pub struct FirstArgs {
+    rows: Option<Tagged<usize>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for First {
+    fn name(&self) -> &str {
+        "first"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("first").optional(
+            "rows",
+            SyntaxShape::Int,
+            "starting from the front, the number of rows to return",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Show only the first number of rows."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        first(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Return the first item of a list/table",
+                example: "echo [1 2 3] | first",
+                result: Some(vec![UntaggedValue::int(1).into()]),
+            },
+            Example {
+                description: "Return the first 2 items of a list/table",
+                example: "echo [1 2 3] | first 2",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(2).into(),
+                ]),
+            },
+        ]
+    }
+}
+
+async fn first(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let (FirstArgs { rows }, input) = args.process(&registry).await?;
+    let rows_desired = if let Some(quantity) = rows {
+        *quantity
+    } else {
+        1
+    };
+
+    Ok(input.take(rows_desired).to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::First;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(First {})?)
+    }
+}

crates/nu-cli/src/commands/format.rs

@@ -0,0 +1,162 @@
+use crate::command_registry::CommandRegistry;
+use crate::commands::WholeStreamCommand;
+use crate::evaluate::evaluate_baseline_expr;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+use std::borrow::Borrow;
+
+pub struct Format;
+
+#[derive(Deserialize)]
+pub struct FormatArgs {
+    pattern: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Format {
+    fn name(&self) -> &str {
+        "format"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("format").required(
+            "pattern",
+            SyntaxShape::String,
+            "the pattern to output. Eg) \"{foo}: {bar}\"",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Format columns into a string using a simple pattern."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        format_command(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Print filenames with their sizes",
+            example: "ls | format '{name}: {size}'",
+            result: None,
+        }]
+    }
+}
+
+async fn format_command(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = Arc::new(registry.clone());
+    let scope = args.call_info.scope.clone();
+    let (FormatArgs { pattern }, input) = args.process(&registry).await?;
+
+    let format_pattern = format(&pattern);
+    let commands = Arc::new(format_pattern);
+
+    Ok(input
+        .then(move |value| {
+            let mut output = String::new();
+            let commands = commands.clone();
+            let registry = registry.clone();
+            let scope = scope.clone();
+
+            async move {
+                for command in &*commands {
+                    match command {
+                        FormatCommand::Text(s) => {
+                            output.push_str(&s);
+                        }
+                        FormatCommand::Column(c) => {
+                            // FIXME: use the correct spans
+                            let full_column_path = nu_parser::parse_full_column_path(
+                                &(c.to_string()).spanned(Span::unknown()),
+                                &*registry,
+                            );
+
+                            let result = evaluate_baseline_expr(
+                                &full_column_path.0,
+                                &registry,
+                                Scope::append_it(scope.clone(), value.clone()),
+                            )
+                            .await;
+
+                            if let Ok(c) = result {
+                                output
+                                    .push_str(&value::format_leaf(c.borrow()).plain_string(100_000))
+                            } else {
+                                // That column doesn't match, so don't emit anything
+                            }
+                        }
+                    }
+                }
+
+                ReturnSuccess::value(UntaggedValue::string(output).into_untagged_value())
+            }
+        })
+        .to_output_stream())
+}
+
+#[derive(Debug)]
+enum FormatCommand {
+    Text(String),
+    Column(String),
+}
+
+fn format(input: &str) -> Vec<FormatCommand> {
+    let mut output = vec![];
+
+    let mut loop_input = input.chars();
+    loop {
+        let mut before = String::new();
+
+        while let Some(c) = loop_input.next() {
+            if c == '{' {
+                break;
+            }
+            before.push(c);
+        }
+
+        if !before.is_empty() {
+            output.push(FormatCommand::Text(before.to_string()));
+        }
+        // Look for column as we're now at one
+        let mut column = String::new();
+
+        while let Some(c) = loop_input.next() {
+            if c == '}' {
+                break;
+            }
+            column.push(c);
+        }
+
+        if !column.is_empty() {
+            output.push(FormatCommand::Column(column.to_string()));
+        }
+
+        if before.is_empty() && column.is_empty() {
+            break;
+        }
+    }
+
+    output
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Format;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Format {})?)
+    }
+}

crates/nu-cli/src/commands/from.rs

@@ -0,0 +1,46 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct From;
+
+#[async_trait]
+impl WholeStreamCommand for From {
+    fn name(&self) -> &str {
+        "from"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse content (string or binary) as a table (input format based on subcommand, like csv, ini, json, toml)"
+    }
+
+    async fn run(
+        &self,
+        _args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let registry = registry.clone();
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(crate::commands::help::get_help(&From, &registry))
+                .into_value(Tag::unknown()),
+        )))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::From;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(From {})?)
+    }
+}

crates/nu-cli/src/commands/from_csv.rs

@@ -0,0 +1,120 @@
+use crate::commands::from_delimited_data::from_delimited_data;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct FromCSV;
+
+#[derive(Deserialize)]
+pub struct FromCSVArgs {
+    headerless: bool,
+    separator: Option<Value>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FromCSV {
+    fn name(&self) -> &str {
+        "from csv"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from csv")
+            .named(
+                "separator",
+                SyntaxShape::String,
+                "a character to separate columns, defaults to ','",
+                Some('s'),
+            )
+            .switch(
+                "headerless",
+                "don't treat the first row as column names",
+                None,
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .csv and create table."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        from_csv(args, registry).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert comma-separated data to a table",
+                example: "open data.txt | from csv",
+                result: None,
+            },
+            Example {
+                description: "Convert comma-separated data to a table, ignoring headers",
+                example: "open data.txt | from csv --headerless",
+                result: None,
+            },
+            Example {
+                description: "Convert semicolon-separated data to a table",
+                example: "open data.txt | from csv --separator ';'",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn from_csv(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let registry = registry.clone();
+    let name = args.call_info.name_tag.clone();
+
+    let (
+        FromCSVArgs {
+            headerless,
+            separator,
+        },
+        input,
+    ) = args.process(&registry).await?;
+    let sep = match separator {
+        Some(Value {
+            value: UntaggedValue::Primitive(Primitive::String(s)),
+            tag,
+            ..
+        }) => {
+            if s == r"\t" {
+                '\t'
+            } else {
+                let vec_s: Vec<char> = s.chars().collect();
+                if vec_s.len() != 1 {
+                    return Err(ShellError::labeled_error(
+                        "Expected a single separator char from --separator",
+                        "requires a single character string input",
+                        tag,
+                    ));
+                };
+                vec_s[0]
+            }
+        }
+        _ => ',',
+    };
+
+    from_delimited_data(headerless, sep, "CSV", input, name).await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromCSV;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromCSV {})?)
+    }
+}

crates/nu-cli/src/commands/from_delimited_data.rs

@@ -0,0 +1,105 @@
+use crate::prelude::*;
+use csv::{ErrorKind, ReaderBuilder};
+use nu_errors::ShellError;
+use nu_protocol::{TaggedDictBuilder, UntaggedValue, Value};
+
+fn from_delimited_string_to_value(
+    s: String,
+    headerless: bool,
+    separator: char,
+    tag: impl Into<Tag>,
+) -> Result<Value, csv::Error> {
+    let mut reader = ReaderBuilder::new()
+        .has_headers(!headerless)
+        .delimiter(separator as u8)
+        .from_reader(s.as_bytes());
+    let tag = tag.into();
+    let span = tag.span;
+
+    let headers = if headerless {
+        (1..=reader.headers()?.len())
+            .map(|i| format!("Column{}", i))
+            .collect::<Vec<String>>()
+    } else {
+        reader.headers()?.iter().map(String::from).collect()
+    };
+
+    let mut rows = vec![];
+    for row in reader.records() {
+        let mut tagged_row = TaggedDictBuilder::new(&tag);
+        for (value, header) in row?.iter().zip(headers.iter()) {
+            if let Ok(i) = value.parse::<i64>() {
+                tagged_row.insert_value(header, UntaggedValue::int(i).into_value(&tag))
+            } else if let Ok(f) = value.parse::<f64>() {
+                tagged_row.insert_value(
+                    header,
+                    UntaggedValue::decimal_from_float(f, span).into_value(&tag),
+                )
+            } else {
+                tagged_row.insert_value(header, UntaggedValue::string(value).into_value(&tag))
+            }
+        }
+        rows.push(tagged_row.into_value());
+    }
+
+    Ok(UntaggedValue::Table(rows).into_value(&tag))
+}
+
+pub async fn from_delimited_data(
+    headerless: bool,
+    sep: char,
+    format_name: &'static str,
+    input: InputStream,
+    name: Tag,
+) -> Result<OutputStream, ShellError> {
+    let name_tag = name;
+    let concat_string = input.collect_string(name_tag.clone()).await?;
+
+    match from_delimited_string_to_value(concat_string.item, headerless, sep, name_tag.clone()) {
+        Ok(x) => match x {
+            Value {
+                value: UntaggedValue::Table(list),
+                ..
+            } => Ok(futures::stream::iter(list).to_output_stream()),
+            x => Ok(OutputStream::one(x)),
+        },
+        Err(err) => {
+            let line_one = match pretty_csv_error(err) {
+                Some(pretty) => format!("Could not parse as {} ({})", format_name, pretty),
+                None => format!("Could not parse as {}", format_name),
+            };
+            let line_two = format!("input cannot be parsed as {}", format_name);
+
+            Err(ShellError::labeled_error_with_secondary(
+                line_one,
+                line_two,
+                name_tag.clone(),
+                "value originates from here",
+                concat_string.tag,
+            ))
+        }
+    }
+}
+
+fn pretty_csv_error(err: csv::Error) -> Option<String> {
+    match err.kind() {
+        ErrorKind::UnequalLengths {
+            pos,
+            expected_len,
+            len,
+        } => {
+            if let Some(pos) = pos {
+                Some(format!(
+                    "Line {}: expected {} fields, found {}",
+                    pos.line(),
+                    expected_len,
+                    len
+                ))
+            } else {
+                Some(format!("Expected {} fields, found {}", expected_len, len))
+            }
+        }
+        ErrorKind::Seek => Some("Internal error while parsing csv".to_string()),
+        _ => None,
+    }
+}

crates/nu-cli/src/commands/from_eml.rs

@@ -0,0 +1,141 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use ::eml_parser::eml::*;
+use ::eml_parser::EmlParser;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct FromEML;
+
+const DEFAULT_BODY_PREVIEW: usize = 50;
+
+#[derive(Deserialize, Clone)]
+pub struct FromEMLArgs {
+    #[serde(rename(deserialize = "preview-body"))]
+    preview_body: Option<Tagged<usize>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FromEML {
+    fn name(&self) -> &str {
+        "from eml"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from eml").named(
+            "preview-body",
+            SyntaxShape::Int,
+            "How many bytes of the body to preview",
+            Some('b'),
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .eml and create table."
+    }
+
+    async fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        from_eml(args, registry).await
+    }
+}
+
+fn emailaddress_to_value(tag: &Tag, email_address: &EmailAddress) -> TaggedDictBuilder {
+    let mut dict = TaggedDictBuilder::with_capacity(tag, 2);
+    let (n, a) = match email_address {
+        EmailAddress::AddressOnly { address } => {
+            (UntaggedValue::nothing(), UntaggedValue::string(address))
+        }
+        EmailAddress::NameAndEmailAddress { name, address } => {
+            (UntaggedValue::string(name), UntaggedValue::string(address))
+        }
+    };
+
+    dict.insert_untagged("Name", n);
+    dict.insert_untagged("Address", a);
+
+    dict
+}
+
+fn headerfieldvalue_to_value(tag: &Tag, value: &HeaderFieldValue) -> UntaggedValue {
+    use HeaderFieldValue::*;
+
+    match value {
+        SingleEmailAddress(address) => emailaddress_to_value(tag, address).into_untagged_value(),
+        MultipleEmailAddresses(addresses) => UntaggedValue::Table(
+            addresses
+                .iter()
+                .map(|a| emailaddress_to_value(tag, a).into_value())
+                .collect(),
+        ),
+        Unstructured(s) => UntaggedValue::string(s),
+        Empty => UntaggedValue::nothing(),
+    }
+}
+
+async fn from_eml(
+    args: CommandArgs,
+    registry: &CommandRegistry,
+) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let registry = registry.clone();
+    let (eml_args, input): (FromEMLArgs, _) = args.process(&registry).await?;
+    let value = input.collect_string(tag.clone()).await?;
+
+    let body_preview = eml_args
+        .preview_body
+        .map(|b| b.item)
+        .unwrap_or(DEFAULT_BODY_PREVIEW);
+
+    let eml = EmlParser::from_string(value.item)
+        .with_body_preview(body_preview)
+        .parse()
+        .map_err(|_| {
+            ShellError::labeled_error(
+                "Could not parse .eml file",
+                "could not parse .eml file",
+                &tag,
+            )
+        })?;
+
+    let mut dict = TaggedDictBuilder::new(&tag);
+
+    if let Some(subj) = eml.subject {
+        dict.insert_untagged("Subject", UntaggedValue::string(subj));
+    }
+
+    if let Some(from) = eml.from {
+        dict.insert_untagged("From", headerfieldvalue_to_value(&tag, &from));
+    }
+
+    if let Some(to) = eml.to {
+        dict.insert_untagged("To", headerfieldvalue_to_value(&tag, &to));
+    }
+
+    for HeaderField { name, value } in eml.headers.iter() {
+        dict.insert_untagged(name, headerfieldvalue_to_value(&tag, &value));
+    }
+
+    if let Some(body) = eml.body {
+        dict.insert_untagged("Body", UntaggedValue::string(body));
+    }
+
+    Ok(OutputStream::one(ReturnSuccess::value(dict.into_value())))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromEML;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromEML {})?)
+    }
+}