Update release.yml

* WIP

* semi-revert metadata change

.azure/azure-pipelines.yml

@@ -1,59 +0,0 @@
-trigger:
-  - master
-
-strategy:
-  matrix:
-    linux-stable:
-      image: ubuntu-16.04
-      style: 'unflagged'
-    macos-stable:
-      image: macos-10.14
-      style: 'unflagged'
-    windows-stable:
-      image: vs2017-win2016
-      style: 'unflagged'
-    linux-nightly-canary:
-      image: ubuntu-16.04
-      style: 'canary'
-    macos-nightly-canary:
-      image: macos-10.14
-      style: 'canary'
-    windows-nightly-canary:
-      image: vs2017-win2016
-      style: 'canary'
-    fmt:
-      image: ubuntu-16.04
-      style: 'fmt'
-
-pool:
-  vmImage: $(image)
-
-steps:
-  - bash: |
-      set -e
-      if [ -e /etc/debian_version ]
-      then
-        sudo apt-get -y install libxcb-composite0-dev libx11-dev
-      fi
-      curl https://sh.rustup.rs -sSf | sh -s -- -y --no-modify-path --default-toolchain "stable"
-      export PATH=$HOME/.cargo/bin:$PATH
-      rustup update
-      rustc -Vv
-      echo "##vso[task.prependpath]$HOME/.cargo/bin"
-      rustup component add rustfmt --toolchain "stable"
-    displayName: Install Rust
-  - bash: RUSTFLAGS="-D warnings" cargo test --all --features=stable
-    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
-    condition: eq(variables['style'], 'unflagged')
-    displayName: Check clippy lints
-  - bash: NUSHELL_ENABLE_ALL_FLAGS=1 RUSTFLAGS="-D warnings" cargo test --all --features=stable
-    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
-    condition: eq(variables['style'], 'canary')
-    displayName: Check clippy lints
-  - 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,13 @@
+# increase the default windows stack size
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-C", "link-args=-stack:10000000"]
+
+# keeping this but commentting out in case we need them in the future
+
+# set a 2 gb stack size (0x80000000 = 2147483648 bytes = 2 GB)
+# [target.x86_64-unknown-linux-gnu]
+# rustflags = ["-C", "link-args=-Wl,-z stack-size=0x80000000"]
+
+# set a 2 gb stack size (0x80000000 = 2147483648 bytes = 2 GB)
+# [target.x86_64-apple-darwin]
+# rustflags = ["-C", "link-args=-Wl,-stack_size,0x80000000"]

.circleci/config.yml

@@ -1,165 +0,0 @@
-# CircleCI 2.0 configuration file
-#
-# Check https://circleci.com/docs/2.0/configuration-reference/ for more details
-# See https://circleci.com/docs/2.0/config-intro/#section=configuration for spec
-#
-version: 2.1
-
-# Commands
-
-commands:
-
-  pull_cache:
-    description: Pulls Quay.io docker images (latest) for our cache
-    parameters:
-      tag:
-        type: string
-        default: "devel"
-    steps:
-      - run: echo "Tag is << parameters.tag >>"
-      - run: docker pull quay.io/nushell/nu:<< parameters.tag >>
-      - run: docker pull quay.io/nushell/nu-base:<< parameters.tag >>
-
-orbs:
-  # https://circleci.com/orbs/registry/orb/circleci/docker
-  docker: circleci/docker@0.5.13
-
-workflows:
-  version: 2.0
-
-  # This builds on all pull requests to test, and ignores master
-  build_without_deploy:
-    jobs:
-      - docker/publish:
-          deploy: false
-          image: nushell/nu-base
-          tag: latest
-          dockerfile: docker/Dockerfile.nu-base
-          extra_build_args: --cache-from=quay.io/nushell/nu-base:devel
-          filters:
-            branches:
-              ignore: 
-                - master
-          before_build:
-            - pull_cache
-          after_build:
-            - run:
-                name: Build Multistage (smaller) container
-                command: |
-                  docker build -f docker/Dockerfile -t quay.io/nushell/nu .
-            - run:
-                name: Preview Docker Tag for Nushell Build
-                command: |
-                   DOCKER_TAG=$(docker run quay.io/nushell/nu --version | cut -d' ' -f2)
-                   echo "Version that would be used for Docker tag is v${DOCKER_TAG}"
-            - run:
-                name: Test Executable
-                command: |
-                   docker run --rm quay.io/nushell/nu-base --help
-                   docker run --rm quay.io/nushell/nu --help
-
-  # workflow publishes to Docker Hub, with each job having different triggers
-  build_with_deploy:
-    jobs:
-
-        # Deploy versioned and latest images on tags (releases) only - builds --release.
-      - docker/publish:
-          image: nushell/nu-base
-          registry: quay.io
-          tag: latest
-          dockerfile: docker/Dockerfile.nu-base
-          extra_build_args: --cache-from=quay.io/nushell/nu-base:latest,quay.io/nushell/nu:latest --build-arg RELEASE=true
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              only: /^v.*/
-          before_build:
-            - run: docker pull quay.io/nushell/nu:latest
-            - run: docker pull quay.io/nushell/nu-base:latest
-          after_build:
-            - run:
-                name: Build Multistage (smaller) container
-                command: |
-                  docker build -f docker/Dockerfile -t quay.io/nushell/nu .
-            - run:
-                name: Test Executable
-                command: |
-                   docker run --rm quay.io/nushell/nu --help
-                   docker run --rm quay.io/nushell/nu-base --help
-            - run:
-                name: Publish Docker Tag with Nushell Version
-                command: |
-                   DOCKER_TAG=$(docker run quay.io/nushell/nu --version | cut -d' ' -f2)
-                   echo "Version for Docker tag is ${DOCKER_TAG}"
-                   docker tag quay.io/nushell/nu-base:latest quay.io/nushell/nu-base:${DOCKER_TAG}
-                   docker tag quay.io/nushell/nu:latest quay.io/nushell/nu:${DOCKER_TAG}
-                   docker push quay.io/nushell/nu-base
-                   docker push quay.io/nushell/nu
-
-
-  # publish devel to Docker Hub on merge to master (doesn't build --release)
-  build_with_deploy_devel:
-    jobs:
-
-      # Deploy devel tag on merge to master
-      - docker/publish:
-          image: nushell/nu-base
-          registry: quay.io
-          tag: devel
-          dockerfile: docker/Dockerfile.nu-base
-          extra_build_args: --cache-from=quay.io/nushell/nu-base:devel
-          before_build:
-            - pull_cache
-          filters:
-            branches:
-              only: master
-          after_build:
-            - run:
-                name: Build Multistage (smaller) container
-                command: |
-                  docker build --build-arg FROMTAG=devel -f docker/Dockerfile -t quay.io/nushell/nu:devel .
-            - run:
-                name: Test Executable
-                command: |
-                   docker run --rm quay.io/nushell/nu:devel --help
-                   docker run --rm quay.io/nushell/nu-base:devel --help
-            - run:
-                name: Publish Development Docker Tags
-                command: |
-                   docker push quay.io/nushell/nu-base:devel
-                   docker push quay.io/nushell/nu:devel
-
-  nightly:
-    triggers:
-      - schedule:
-          cron: "0 0 * * *"
-          filters:
-            branches:
-              only:
-                - master
-    jobs:
-      - docker/publish:
-          image: nushell/nu-base
-          registry: quay.io
-          tag: nightly
-          dockerfile: docker/Dockerfile.nu-base
-          extra_build_args: --cache-from=quay.io/nushell/nu-base:nightly --build-arg RELEASE=true
-          before_build:
-            - run: docker pull quay.io/nushell/nu:nightly
-            - run: docker pull quay.io/nushell/nu-base:nightly
-          after_build:
-            - run:
-                name: Build Multistage (smaller) container
-                command: |
-                  docker build -f docker/Dockerfile -t quay.io/nushell/nu:nightly .
-            - run:
-                name: Test Executable
-                command: |
-                   docker run --rm quay.io/nushell/nu:nightly --help
-                   docker run --rm quay.io/nushell/nu-base:nightly --help
-            - run:
-                name: Publish Nightly Nushell Containers
-                command: |
-                   docker push quay.io/nushell/nu-base:nightly
-                   docker push quay.io/nushell/nu:nightly

.editorconfig

@@ -1,14 +0,0 @@
-root = true
-
-[*]
-indent_style = space
-indent_size = 4
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = false
-end_of_line = lf
-
-[*.{yml,yaml}]
-indent_size = 2
-charset = utf-8
-insert_final_newline = true

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,30 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. 
-2. 
-3. 
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Configuration (please complete the following information):**
- - OS: [e.g. Windows]
- - Version [e.g. 0.4.0]
- - Optional features (if any)
-
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,63 @@
+name: Bug Report
+description: Create a report to help us improve
+body: 
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the bug
+      description: Thank you for your bug report. We are working diligently with our community to integrate our latest code base that we call [engine-q](https://github.com/nushell/engine-q). We would like your help with this by checking to see if this bug report is still needed in engine-q. Thank you for your patience while we ready the next version of nushell.
+    validations:
+      required: true
+  - type: textarea
+    id: repro
+    attributes:
+      label: How to reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        1.
+        2.
+        3.
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: A clear and concise description of what you expected to happen.
+      placeholder: I expected nu to...
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: Please add any relevant screenshots here, if any
+    validations:
+      required: false
+  - type: textarea
+    id: config
+    attributes:
+      label: Configuration
+      description: "Please run `version | transpose key value | to md --pretty` and paste the output to show OS, features, etc."
+      placeholder: |
+        > version | transpose key value | to md --pretty
+        | key                | value                                                                                                                                                                   |
+        | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+        | version            | 0.40.0                                                                                                                                                                  |
+        | build_os           | linux-x86_64                                                                                                                                                            |
+        | rust_version       | rustc 1.56.1                                                                                                                                                            |
+        | cargo_version      | cargo 1.56.0                                                                                                                                                            |
+        | pkg_version        | 0.40.0                                                                                                                                                                  |
+        | build_time         | 1980-01-01 00:00:00 +00:00                                                                                                                                              |
+        | build_rust_channel | release                                                                                                                                                                 |
+        | features           | clipboard-cli, ctrlc, dataframe, default, rustyline, term, trash, uuid, which, zip                                                                                      |
+        | installed_plugins  | binaryview, chart bar, chart line, fetch, from bson, from sqlite, inc, match, post, ps, query json, s3, selector, start, sys, textview, to bson, to sqlite, tree, xpath |
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,34 @@
+name: Feature Request
+description: "When you want a new feature for something that doesn't already exist"
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: Related problem
+      description: Thank you for your feature request. We are working diligently with our community to integrate our latest code base that we call [engine-q](https://github.com/nushell/engine-q). We would like your help with this by checking to see if this feature request is still needed in engine-q. Thank you for your patience while we ready the next version of nushell.
+      placeholder: |
+        A clear and concise description of what the problem is.
+        Example: I am trying to do [...] but [...]
+    validations:
+      required: false
+  - type: textarea
+    id: desired
+    attributes:
+      label: "Describe the solution you'd like"
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: "Describe alternatives you've considered"
+      description: "A clear and concise description of any alternative solutions or features you've considered."
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context and details
+      description: Add any other context or screenshots about the feature request here.
+    validations:
+      required: false

.github/pull_request_template.md

@@ -0,0 +1,11 @@
+# Description
+
+(description of your pull request here)
+
+# Tests
+
+Make sure you've run and fixed any issues with these commands:
+
+- [ ] `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes)
+- [ ] `cargo clippy --all --all-features -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect` to check that you're using the standard code style
+- [ ] `cargo build; cargo test --all --all-features` to check that all the tests pass

.github/workflows/ci.yml

@@ -0,0 +1,114 @@
+on: [pull_request]
+
+name: Continuous integration
+
+jobs:
+  ci:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [windows-latest, macos-latest, ubuntu-latest]
+        style: [all, default, minimal]
+        rust:
+          - stable
+        include:
+          - style: all
+            flags: '--all-features'
+          - style: default
+            flags: ''
+          - style: minimal
+            flags: '--no-default-features'
+        exclude:
+          - platform: windows-latest
+            style: default
+          - platform: windows-latest
+            style: minimal
+          - platform: macos-latest
+            style: default
+          - platform: macos-latest
+            style: minimal
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt, clippy
+
+      - name: Rustfmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - name: Clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --all ${{ matrix.flags }} -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
+
+      - name: Build Nushell
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: ${{ matrix.flags }}
+
+      - name: Tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all ${{ matrix.flags }}
+
+
+  python-virtualenv:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest, macos-latest, windows-latest]
+        rust:
+          - stable
+        py:
+          - py
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt, clippy
+
+      - name: Install Nushell
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: --path=. --no-default-features
+
+      - name: Setup Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.10"
+
+      - run: python -m pip install tox
+
+      - name: Install virtualenv
+        run: |
+          git clone https://github.com/kubouch/virtualenv.git && \
+          cd virtualenv && \
+          git checkout engine-q-update
+        shell: bash
+
+      - name: Test Nushell in virtualenv
+        run: cd virtualenv && tox -e ${{ matrix.py }} -- -k nushell
+        shell: bash

.github/workflows/docker-publish.yml

@@ -1,118 +0,0 @@
-name: Publish consumable Docker images
-
-on:
-  push:
-    tags: ['v?[0-9]+.[0-9]+.[0-9]+*']
-
-jobs:
-  compile:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        arch:
-        - x86_64-unknown-linux-musl
-        - x86_64-unknown-linux-gnu
-    steps:
-    - uses: actions/checkout@v1
-    - name: Install rust-embedded/cross
-      env: { VERSION: v0.1.16 }
-      run: >-
-        wget -nv https://github.com/rust-embedded/cross/releases/download/${VERSION}/cross-${VERSION}-x86_64-unknown-linux-gnu.tar.gz
-        -O- | sudo tar xz -C /usr/local/bin/
-    - name: compile for specific target
-      env: { arch: '${{ matrix.arch }}' }
-      run: |
-        cross build --target ${{ matrix.arch }} --release
-        # leave only the executable file
-        rm -rd target/${{ matrix.arch }}/release/{*/*,*.d,*.rlib,.fingerprint}
-        find . -empty -delete
-    - uses: actions/upload-artifact@master
-      with:
-        name: ${{ matrix.arch }}
-        path: target/${{ matrix.arch }}/release
-
-  docker:
-    name: Build and publish docker images
-    needs: compile
-    runs-on: ubuntu-latest
-    env:
-      DOCKER_REGISTRY: quay.io/nushell
-      DOCKER_PASSWORD: ${{ secrets.DOCKER_REGISTRY }}
-      DOCKER_USER: ${{ secrets.DOCKER_USER }}
-    strategy:
-      matrix:
-        tag:
-        - alpine
-        - slim
-        - debian
-        - glibc-busybox
-        - musl-busybox
-        - musl-distroless
-        - glibc-distroless
-        - glibc
-        - musl
-        include:
-        - { tag: alpine,           base-image: alpine,                     arch: x86_64-unknown-linux-musl, plugin: true    }
-        - { tag: slim,             base-image: 'debian:stable-slim',       arch: x86_64-unknown-linux-gnu,  plugin: true    }
-        - { tag: debian,           base-image: debian,                     arch: x86_64-unknown-linux-gnu,  plugin: true    }
-        - { tag: glibc-busybox,    base-image: 'busybox:glibc',            arch: x86_64-unknown-linux-gnu,  use-patch: true }
-        - { tag: musl-busybox,     base-image: 'busybox:musl',             arch: x86_64-unknown-linux-musl,                 }
-        - { tag: musl-distroless,  base-image: 'gcr.io/distroless/static', arch: x86_64-unknown-linux-musl,                 }
-        - { tag: glibc-distroless, base-image: 'gcr.io/distroless/cc',     arch: x86_64-unknown-linux-gnu,  use-patch: true }
-        - { tag: glibc,            base-image: scratch,                    arch: x86_64-unknown-linux-gnu,                  }
-        - { tag: musl,             base-image: scratch,                    arch: x86_64-unknown-linux-musl,                 }
-    steps:
-    - uses: actions/checkout@v1
-    - uses: actions/download-artifact@master
-      with: { name: '${{ matrix.arch }}', path: target/release }
-    - name: Build and publish exact version
-      run: |-
-        export DOCKER_TAG=${GITHUB_REF##*/}-${{ matrix.tag }}
-        export NU_BINS=target/release/$( [ ${{ matrix.plugin }} = true ] && echo nu* || echo nu )
-        export PATCH=$([ ${{ matrix.use-patch }} = true ] && echo .${{ matrix.tag }} || echo '')
-        chmod +x $NU_BINS
-
-        echo ${DOCKER_PASSWORD} | docker login ${DOCKER_REGISTRY} -u ${DOCKER_USER} --password-stdin
-        docker-compose --file docker/docker-compose.package.yml build
-        docker-compose --file docker/docker-compose.package.yml push              # exact version
-      env:
-        BASE_IMAGE: ${{ matrix.base-image }}
-
-    #region semantics tagging
-    - name: Retag and push with suffixed version
-      run: |-
-        VERSION=${GITHUB_REF##*/}
-
-        latest_version=${VERSION%%%.*}-${{ matrix.tag }}
-        latest_feature=${VERSION%%.*}-${{ matrix.tag }}
-        latest_patch=${VERSION%.*}-${{ matrix.tag }}
-        exact_version=${VERSION}-${{ matrix.tag }}
-
-        tags=( ${latest_version} ${latest_feature} ${latest_patch} ${exact_version} )
-
-        for tag in ${tags[@]}; do
-          docker tag ${DOCKER_REGISTRY}/nu:${VERSION}-${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:${tag}
-          docker push ${DOCKER_REGISTRY}/nu:${tag}
-        done
-
-        # latest version
-        docker tag ${DOCKER_REGISTRY}/nu:${VERSION}-${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:${{ matrix.tag }}
-        docker push ${DOCKER_REGISTRY}/nu:${{ matrix.tag }}
-
-    - name: Retag and push debian as latest
-      if: matrix.tag == 'debian'
-      run: |-
-        VERSION=${GITHUB_REF##*/}
-
-        # ${latest features} ${latest patch} ${exact version}
-        tags=( ${VERSION%%.*} ${VERSION%.*} ${VERSION} )
-
-        for tag in ${tags[@]}; do
-          docker tag ${DOCKER_REGISTRY}/nu:${VERSION}-${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:${tag}
-          docker push ${DOCKER_REGISTRY}/nu:${tag}
-        done
-
-        # latest version
-        docker tag ${DOCKER_REGISTRY}/nu:${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:latest
-        docker push ${DOCKER_REGISTRY}/nu:latest
-    #endregion semantics tagging

.github/workflows/release.yml

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

.github/workflows/stale.yml

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

.github/workflows/winget-submission.yml

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

.gitignore

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

.gitpod.Dockerfile

@@ -1,7 +0,0 @@
-FROM gitpod/workspace-full
-USER root
-RUN apt-get update && apt-get install -y libssl-dev \
-    libxcb-composite0-dev \
-    pkg-config \
-    curl \
-    rustc

.gitpod.yml

@@ -1,21 +0,0 @@
-image:
-  file: .gitpod.Dockerfile
-tasks:
-  - init: cargo install nu --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

CODE_OF_CONDUCT.md

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

CONTRIBUTING.md

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

Cargo.toml

@@ -1,208 +1,103 @@
 [package]
-name = "nu"
-version = "0.8.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 Nushell Project Developers"]
 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/"
-
-[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"
-]
+edition = "2018"
+exclude = ["images"]
+homepage = "https://www.nushell.sh"
+license = "MIT"
+name = "nu"
+readme = "README.md"
+repository = "https://github.com/nushell/nushell"
+version = "0.60.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[workspace]
+members = [
+	"crates/nu-cli",
+	"crates/nu-engine",
+	"crates/nu-parser",
+	"crates/nu-system",
+	"crates/nu-command",
+	"crates/nu-protocol",
+	"crates/nu-plugin",
+	"crates/nu_plugin_inc",
+	"crates/nu_plugin_gstat",
+	"crates/nu_plugin_example",
+	"crates/nu_plugin_query",
+	"crates/nu-utils",
+]
+
 [dependencies]
-nu-source = { version = "0.8.0", path = "./crates/nu-source" }
-nu-plugin = { version = "0.8.0", path = "./crates/nu-plugin" }
-nu-protocol = { version = "0.8.0", path = "./crates/nu-protocol" }
-nu-errors = { version = "0.8.0", path = "./crates/nu-errors" }
-nu-parser = { version = "0.8.0", path = "./crates/nu-parser" }
-nu-value-ext = { version = "0.8.0", path = "./crates/nu-value-ext" }
-nu_plugin_average = {version = "0.8.0", path = "./crates/nu_plugin_average", optional=true}
-nu_plugin_binaryview = {version = "0.8.0", path = "./crates/nu_plugin_binaryview", optional=true}
-nu_plugin_fetch = {version = "0.8.0", path = "./crates/nu_plugin_fetch", optional=true}
-nu_plugin_inc = {version = "0.8.0", path = "./crates/nu_plugin_inc", optional=true}
-nu_plugin_match = {version = "0.8.0", path = "./crates/nu_plugin_match", optional=true}
-nu_plugin_post = {version = "0.8.0", path = "./crates/nu_plugin_post", optional=true}
-nu_plugin_ps = {version = "0.8.0", path = "./crates/nu_plugin_ps", optional=true}
-nu_plugin_str = {version = "0.8.0", path = "./crates/nu_plugin_str", optional=true}
-nu_plugin_sum = {version = "0.8.0", path = "./crates/nu_plugin_sum", optional=true}
-nu_plugin_sys = {version = "0.8.0", path = "./crates/nu_plugin_sys", optional=true}
-nu_plugin_textview = {version = "0.8.0", path = "./crates/nu_plugin_textview", optional=true}
-nu_plugin_tree = {version = "0.8.0", path = "./crates/nu_plugin_tree", optional=true}
-nu-macros = { version = "0.8.0", path = "./crates/nu-macros" }
-
-
-query_interface = "0.3.5"
-typetag = "0.1.4"
-rustyline = "5.0.6"
-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.0", features = ["serde-1"] }
-chrono-humanize = "0.0.11"
-byte-unit = "3.0.3"
-base64 = "0.11"
-futures-preview = { version = "=0.3.0-alpha.19", features = ["compat", "io-compat"] }
-async-stream = "0.1.2"
-futures_codec = "0.2.5"
-num-traits = "0.2.10"
-term = "0.5.2"
-bytes = "0.4.12"
-log = "0.4.8"
-pretty_env_logger = "0.3.1"
-serde = { version = "1.0.103", features = ["derive"] }
-bson = { version = "0.14.0", features = ["decimal128"] }
-serde_json = "1.0.44"
-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.5"
-clap = "2.33.0"
-git2 = { version = "0.10.2", default_features = false }
-dirs = "2.0.2"
-glob = "0.3.0"
-ctrlc = "3.1.3"
-roxmltree = "0.7.3"
-nom_locate = "1.0.0"
-nom-tracable = "0.4.1"
-unicode-xid = "0.2.0"
-serde_ini = "0.2.0"
-subprocess = "0.1.18"
-pretty-hex = "0.1.1"
-hex = "0.4"
-tempfile = "3.1.0"
-ichwh = "0.2"
-textwrap = {version = "0.11.0", features = ["term_size"]}
-shellexpand = "1.0.0"
-pin-utils = "0.1.0-alpha.4"
-num-bigint = { version = "0.2.3", 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.1"
-termcolor = "1.0.5"
-natural = "0.3.0"
-parking_lot = "0.10.0"
-
-clipboard = {version = "0.5", optional = true }
-ptree = {version = "0.2" }
-starship = { version = "0.28", optional = true}
-heim = {version = "0.0.9", optional = true}
-battery = {version = "0.7.5", optional = true}
-syntect = {version = "3.2.0", optional = true }
-onig_sys = {version = "=69.1.0", optional = true }
-crossterm = {version = "0.10.2", optional = true}
-futures-timer = {version = "1.0.2", optional = true}
-url = {version = "2.1.0", optional = true}
-
-[features]
-default = ["sys", "ps", "textview", "inc", "str"]
-stable = ["sys", "ps", "textview", "inc", "str", "starship-prompt", "binaryview", "match", "tree", "average", "sum", "post", "fetch", "clipboard"]
-
-# Default
-sys = ["heim", "battery"]
-ps = ["heim", "futures-timer"]
-textview = ["crossterm", "syntect", "onig_sys", "url"]
-inc = ["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"]
+chrono = "0.4.19"
+crossterm = "0.23.0"
+crossterm_winapi = "0.9.0"
+ctrlc = "3.2.1"
+log = "0.4"
+miette = "4.1.0"
+nu-ansi-term = "0.45.0"
+nu-cli = { path="./crates/nu-cli", version = "0.60.0"  }
+nu-color-config = { path = "./crates/nu-color-config", version = "0.60.0"  }
+nu-command = { path="./crates/nu-command", version = "0.60.0"  }
+nu-engine = { path="./crates/nu-engine", version = "0.60.0"  }
+nu-json = { path="./crates/nu-json", version = "0.60.0"  }
+nu-parser = { path="./crates/nu-parser", version = "0.60.0"  }
+nu-path = { path="./crates/nu-path", version = "0.60.0"  }
+nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.60.0"  }
+nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.60.0"  }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.60.0"  }
+nu-system = { path = "./crates/nu-system", version = "0.60.0" }
+nu-table = { path = "./crates/nu-table", version = "0.60.0"  }
+nu-term-grid = { path = "./crates/nu-term-grid", version = "0.60.0"  }
+nu-utils = { path = "./crates/nu-utils", version = "0.60.0" }
+pretty_env_logger = "0.4.0"
+rayon = "1.5.1"
+reedline = "0.3.0"
+is_executable = "1.0.1"
 
 [dev-dependencies]
-pretty_assertions = "0.6.1"
-nu-test-support = { version = "0.8.0", path = "./crates/nu-test-support" }
+nu-test-support = { path="./crates/nu-test-support" }
+tempfile = "3.2.0"
+assert_cmd = "2.0.2"
+pretty_assertions = "1.0.0"
+serial_test = "0.5.1"
+hamcrest2 = "0.3.0"
+rstest = "0.12.0"
+itertools = "0.10.3"
 
-[build-dependencies]
-toml = "0.5.5"
-serde = { version = "1.0.103", features = ["derive"] }
-nu-build = { version = "0.8.0", path = "./crates/nu-build" }
+[target.'cfg(windows)'.build-dependencies]
+embed-resource = "1"
 
-[lib]
-name = "nu"
-doctest = false
-path = "src/lib.rs"
+[features]
+plugin = ["nu-plugin", "nu-cli/plugin", "nu-parser/plugin", "nu-command/plugin", "nu-protocol/plugin", "nu-engine/plugin"]
+default = ["plugin", "which", "zip-support", "trash-support"]
+stable = ["default"]
+extra = ["default", "dataframe"]
+wasi = []
 
-# Core plugins that ship with `cargo install nu` by default
-# Currently, Cargo limits us to installing only one binary
-# unless we use [[bin]], so we use this as a workaround
-[[bin]]
-name = "nu_plugin_core_textview"
-path = "src/plugins/nu_plugin_core_textview.rs"
-required-features = ["textview"]
+# Stable (Default)
+which = ["nu-command/which"]
+zip-support = ["nu-command/zip"]
+trash-support = ["nu-command/trash-support"]
 
-[[bin]]
-name = "nu_plugin_core_inc"
-path = "src/plugins/nu_plugin_core_inc.rs"
-required-features = ["inc"]
+# Extra
 
-[[bin]]
-name = "nu_plugin_core_ps"
-path = "src/plugins/nu_plugin_core_ps.rs"
-required-features = ["ps"]
+# Dataframe feature for nushell
+dataframe = ["nu-command/dataframe"]
 
-[[bin]]
-name = "nu_plugin_core_str"
-path = "src/plugins/nu_plugin_core_str.rs"
-required-features = ["str"]
+[profile.release]
+opt-level = "s" # Optimize for size
+strip = "debuginfo"
+lto = "thin"
 
-[[bin]]
-name = "nu_plugin_core_sys"
-path = "src/plugins/nu_plugin_core_sys.rs"
-required-features = ["sys"]
+# build with `cargo build --profile profiling`
+# to analyze performance with tooling like linux perf
+[profile.profiling]
+inherits = "release"
+strip = false
+debug = true
 
 # Main nu binary
 [[bin]]

LICENSE

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

TODO.md

@@ -1,52 +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

assets/nushell.rc

@@ -0,0 +1,49 @@
+#include <winver.h>
+
+#define VER_FILEVERSION 0,59,1,0
+#define VER_FILEVERSION_STR "0.59.1"
+
+#define VER_PRODUCTVERSION 0,59,1,0
+#define VER_PRODUCTVERSION_STR "0.59.1"
+
+#ifdef RC_INVOKED
+
+#ifdef DEBUG // TODO: Actually define DEBUG
+#define VER_DEBUG VS_FF_DEBUG
+#else
+#define VER_DEBUG 0
+#endif
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION VER_FILEVERSION
+PRODUCTVERSION VER_PRODUCTVERSION
+FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
+FILEFLAGS VER_DEBUG
+FILEOS VOS__WINDOWS32
+FILETYPE VFT_APP
+FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "nushell"
+            VALUE "FileDescription", "Nushell"
+            VALUE "FileVersion", VER_FILEVERSION_STR
+            VALUE "InternalName", "nu.exe"
+            VALUE "LegalCopyright", "Copyright (C) 2022"
+            VALUE "OriginalFilename", "nu.exe"
+            VALUE "ProductName", "Nushell"
+            VALUE "ProductVersion", VER_PRODUCTVERSION_STR
+        END
+    END
+
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#define IDI_ICON 0x101
+IDI_ICON ICON "assets/nu_logo.ico"
+#endif

build-all-maclin.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+echo "---------------------------------------------------------------"
+echo "Building nushell (nu) with --features=extra and all the plugins"
+echo "---------------------------------------------------------------"
+echo ""
+
+NU_PLUGINS=(
+    'nu_plugin_example'
+    'nu_plugin_gstat'
+    'nu_plugin_inc'
+    'nu_plugin_query'
+)
+
+echo "Building nushell"
+cargo build --features=extra
+for plugin in "${NU_PLUGINS[@]}"
+do
+    echo '' && cd crates/$plugin
+    echo "Building $plugin..."
+    echo "-----------------------------"
+    cargo build && cd ../..
+done

build-all-windows.cmd

@@ -0,0 +1,32 @@
+@echo off
+@echo -------------------------------------------------------------------
+@echo Building nushell (nu.exe) with --features=extra and all the plugins
+@echo -------------------------------------------------------------------
+@echo.
+
+echo Building nushell.exe
+cargo build --features=extra
+@echo.
+
+@cd crates\nu_plugin_example
+echo Building nu_plugin_example.exe
+cargo build
+@echo.
+
+@cd ..\..\crates\nu_plugin_gstat
+echo Building nu_plugin_gstat.exe
+cargo build
+@echo.
+
+@cd ..\..\crates\nu_plugin_inc
+echo Building nu_plugin_inc.exe
+cargo build
+@echo.
+
+@cd ..\..\crates\nu_plugin_query
+
+echo Building nu_plugin_query.exe
+cargo build
+@echo.
+
+@cd ..\..

build-all.nu

@@ -0,0 +1,22 @@
+echo '-------------------------------------------------------------------'
+echo 'Building nushell (nu) with --features=extra and all the plugins'
+echo '-------------------------------------------------------------------'
+
+echo $'(char nl)Building nushell'
+echo '----------------------------'
+cargo build --features=extra
+
+let plugins = [
+    nu_plugin_inc,
+    nu_plugin_gstat,
+    nu_plugin_query,
+    nu_plugin_example,
+]
+
+for plugin in $plugins {
+    $'(char nl)Building ($plugin)'
+    '----------------------------'
+    cd $'crates/($plugin)'
+    cargo build
+    ignore
+}

build.rs

@@ -1,3 +1,7 @@
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    nu_build::build()
+#[cfg(windows)]
+fn main() {
+    embed_resource::compile_for("assets/nushell.rc", &["nu"])
 }
+
+#[cfg(not(windows))]
+fn main() {}

crates/README.md

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

crates/nu-build/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "nu-build"
-version = "0.8.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,26 @@
+[package]
+name = "nu-cli"
+version = "0.60.0"
+edition = "2021"
+
+[dependencies]
+nu-engine = { path = "../nu-engine", version = "0.60.0"  }
+nu-path = { path = "../nu-path", version = "0.60.0"  }
+nu-parser = { path = "../nu-parser", version = "0.60.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.60.0"  }
+nu-utils = { path = "../nu-utils", version = "0.60.0"  }
+nu-ansi-term = "0.45.0"
+
+nu-color-config = { path = "../nu-color-config" }
+
+crossterm = "0.23.0"
+crossterm_winapi = "0.9.0"
+miette = { version = "4.1.0", features = ["fancy"] }
+thiserror = "1.0.29"
+reedline = "0.3.0"
+
+log = "0.4"
+is_executable = "1.0.1"
+
+[features]
+plugin = []

crates/nu-cli/src/commands.rs

@@ -0,0 +1,103 @@
+use crate::util::report_error;
+use log::info;
+use miette::Result;
+use nu_engine::{convert_env_values, eval_block};
+use nu_parser::{parse, trim_quotes};
+use nu_protocol::engine::Stack;
+use nu_protocol::{
+    engine::{EngineState, StateDelta, StateWorkingSet},
+    Config, PipelineData, Spanned,
+};
+use std::path::Path;
+
+pub fn evaluate_commands(
+    commands: &Spanned<String>,
+    init_cwd: &Path,
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    input: PipelineData,
+    is_perf_true: bool,
+) -> Result<()> {
+    // Run a command (or commands) given to us by the user
+    let (block, delta) = {
+        let mut working_set = StateWorkingSet::new(engine_state);
+
+        let (input, _) = if commands.item.starts_with('\'') || commands.item.starts_with('"') {
+            (
+                trim_quotes(commands.item.as_bytes()),
+                commands.span.start + 1,
+            )
+        } else {
+            (commands.item.as_bytes(), commands.span.start)
+        };
+
+        let (output, err) = parse(&mut working_set, None, input, false, &[]);
+        if let Some(err) = err {
+            report_error(&working_set, &err);
+
+            std::process::exit(1);
+        }
+
+        (output, working_set.render())
+    };
+
+    if let Err(err) = engine_state.merge_delta(delta, None, init_cwd) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &err);
+    }
+
+    let config = match stack.get_config() {
+        Ok(config) => config,
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &e);
+            Config::default()
+        }
+    };
+
+    // Make a note of the exceptions we see for externals that look like math expressions
+    let exceptions = crate::util::external_exceptions(engine_state, stack);
+    engine_state.external_exceptions = exceptions;
+
+    // Merge the delta in case env vars changed in the config
+    match nu_engine::env::current_dir(engine_state, stack) {
+        Ok(cwd) => {
+            if let Err(e) = engine_state.merge_delta(StateDelta::new(), Some(stack), cwd) {
+                let working_set = StateWorkingSet::new(engine_state);
+                report_error(&working_set, &e);
+                std::process::exit(1);
+            }
+        }
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
+            std::process::exit(1);
+        }
+    }
+
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+        std::process::exit(1);
+    }
+
+    match eval_block(engine_state, stack, &block, input, false, false) {
+        Ok(pipeline_data) => {
+            crate::eval_file::print_table_or_error(engine_state, stack, pipeline_data, &config)
+        }
+        Err(err) => {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &err);
+            std::process::exit(1);
+        }
+    }
+
+    if is_perf_true {
+        info!("evaluate {}:{}:{}", file!(), line!(), column!());
+    }
+
+    Ok(())
+}

crates/nu-cli/src/completions.rs

@@ -0,0 +1,636 @@
+use nu_engine::eval_call;
+use nu_parser::{flatten_expression, parse, trim_quotes, FlatShape};
+use nu_protocol::{
+    ast::{Call, Expr},
+    engine::{EngineState, Stack, StateWorkingSet},
+    PipelineData, Span, Value, CONFIG_VARIABLE_ID,
+};
+use reedline::Completer;
+
+const SEP: char = std::path::MAIN_SEPARATOR;
+
+pub struct CompletionOptions {
+    case_sensitive: bool,
+    positional: bool,
+    sort: bool,
+}
+
+impl Default for CompletionOptions {
+    fn default() -> Self {
+        Self {
+            case_sensitive: true,
+            positional: true,
+            sort: true,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct NuCompleter {
+    engine_state: EngineState,
+    config: Option<Value>,
+}
+
+impl NuCompleter {
+    pub fn new(engine_state: EngineState, config: Option<Value>) -> Self {
+        Self {
+            engine_state,
+            config,
+        }
+    }
+
+    fn external_command_completion(&self, prefix: &str) -> Vec<String> {
+        let mut executables = vec![];
+
+        let paths = self.engine_state.env_vars.get("PATH");
+
+        if let Some(paths) = paths {
+            if let Ok(paths) = paths.as_list() {
+                for path in paths {
+                    let path = path.as_string().unwrap_or_default();
+
+                    if let Ok(mut contents) = std::fs::read_dir(path) {
+                        while let Some(Ok(item)) = contents.next() {
+                            if !executables.contains(
+                                &item
+                                    .path()
+                                    .file_name()
+                                    .map(|x| x.to_string_lossy().to_string())
+                                    .unwrap_or_default(),
+                            ) && matches!(
+                                item.path()
+                                    .file_name()
+                                    .map(|x| x.to_string_lossy().starts_with(prefix)),
+                                Some(true)
+                            ) && is_executable::is_executable(&item.path())
+                            {
+                                if let Ok(name) = item.file_name().into_string() {
+                                    executables.push(name);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        executables
+    }
+
+    fn complete_variables(
+        &self,
+        working_set: &StateWorkingSet,
+        prefix: &[u8],
+        span: Span,
+        offset: usize,
+    ) -> Vec<(reedline::Span, String)> {
+        let mut output = vec![];
+
+        let builtins = ["$nu", "$in", "$config", "$env", "$nothing"];
+
+        for builtin in builtins {
+            if builtin.as_bytes().starts_with(prefix) {
+                output.push((
+                    reedline::Span {
+                        start: span.start - offset,
+                        end: span.end - offset,
+                    },
+                    builtin.to_string(),
+                ));
+            }
+        }
+
+        for scope in &working_set.delta.scope {
+            for v in &scope.vars {
+                if v.0.starts_with(prefix) {
+                    output.push((
+                        reedline::Span {
+                            start: span.start - offset,
+                            end: span.end - offset,
+                        },
+                        String::from_utf8_lossy(v.0).to_string(),
+                    ));
+                }
+            }
+        }
+        for scope in &self.engine_state.scope {
+            for v in &scope.vars {
+                if v.0.starts_with(prefix) {
+                    output.push((
+                        reedline::Span {
+                            start: span.start - offset,
+                            end: span.end - offset,
+                        },
+                        String::from_utf8_lossy(v.0).to_string(),
+                    ));
+                }
+            }
+        }
+
+        output.dedup();
+
+        output
+    }
+
+    fn complete_commands(
+        &self,
+        working_set: &StateWorkingSet,
+        span: Span,
+        offset: usize,
+        find_externals: bool,
+    ) -> Vec<(reedline::Span, String)> {
+        let prefix = working_set.get_span_contents(span);
+
+        let results = working_set
+            .find_commands_by_prefix(prefix)
+            .into_iter()
+            .map(move |x| {
+                (
+                    reedline::Span {
+                        start: span.start - offset,
+                        end: span.end - offset,
+                    },
+                    String::from_utf8_lossy(&x).to_string(),
+                )
+            });
+
+        let results_aliases =
+            working_set
+                .find_aliases_by_prefix(prefix)
+                .into_iter()
+                .map(move |x| {
+                    (
+                        reedline::Span {
+                            start: span.start - offset,
+                            end: span.end - offset,
+                        },
+                        String::from_utf8_lossy(&x).to_string(),
+                    )
+                });
+
+        let mut results = results.chain(results_aliases).collect::<Vec<_>>();
+
+        let prefix = working_set.get_span_contents(span);
+        let prefix = String::from_utf8_lossy(prefix).to_string();
+        if find_externals {
+            let results_external =
+                self.external_command_completion(&prefix)
+                    .into_iter()
+                    .map(move |x| {
+                        (
+                            reedline::Span {
+                                start: span.start - offset,
+                                end: span.end - offset,
+                            },
+                            x,
+                        )
+                    });
+
+            for external in results_external {
+                if results.contains(&external) {
+                    results.push((external.0, format!("^{}", external.1)))
+                } else {
+                    results.push(external)
+                }
+            }
+
+            results
+        } else {
+            results
+        }
+    }
+
+    fn completion_helper(&self, line: &str, pos: usize) -> Vec<(reedline::Span, String)> {
+        let mut working_set = StateWorkingSet::new(&self.engine_state);
+        let offset = working_set.next_span_start();
+        let mut line = line.to_string();
+        line.insert(pos, 'a');
+        let pos = offset + pos;
+        let (output, _err) = parse(
+            &mut working_set,
+            Some("completer"),
+            line.as_bytes(),
+            false,
+            &[],
+        );
+
+        for pipeline in output.pipelines.into_iter() {
+            for expr in pipeline.expressions {
+                let flattened: Vec<_> = flatten_expression(&working_set, &expr);
+
+                for (flat_idx, flat) in flattened.iter().enumerate() {
+                    if pos >= flat.0.start && pos < flat.0.end {
+                        let new_span = Span {
+                            start: flat.0.start,
+                            end: flat.0.end - 1,
+                        };
+
+                        let mut prefix = working_set.get_span_contents(flat.0).to_vec();
+                        prefix.remove(pos - flat.0.start);
+
+                        if prefix.starts_with(b"$") {
+                            let mut output =
+                                self.complete_variables(&working_set, &prefix, new_span, offset);
+                            output.sort_by(|a, b| a.1.cmp(&b.1));
+                            return output;
+                        }
+                        if prefix.starts_with(b"-") {
+                            // this might be a flag, let's see
+                            if let Expr::Call(call) = &expr.expr {
+                                let decl = working_set.get_decl(call.decl_id);
+                                let sig = decl.signature();
+
+                                let mut output = vec![];
+
+                                for named in &sig.named {
+                                    if let Some(short) = named.short {
+                                        let mut named = vec![0; short.len_utf8()];
+                                        short.encode_utf8(&mut named);
+                                        named.insert(0, b'-');
+                                        if named.starts_with(&prefix) {
+                                            output.push((
+                                                reedline::Span {
+                                                    start: new_span.start - offset,
+                                                    end: new_span.end - offset,
+                                                },
+                                                String::from_utf8_lossy(&named).to_string(),
+                                            ));
+                                        }
+                                    }
+
+                                    if named.long.is_empty() {
+                                        continue;
+                                    }
+
+                                    let mut named = named.long.as_bytes().to_vec();
+                                    named.insert(0, b'-');
+                                    named.insert(0, b'-');
+                                    if named.starts_with(&prefix) {
+                                        output.push((
+                                            reedline::Span {
+                                                start: new_span.start - offset,
+                                                end: new_span.end - offset,
+                                            },
+                                            String::from_utf8_lossy(&named).to_string(),
+                                        ));
+                                    }
+                                }
+                                output.sort_by(|a, b| a.1.cmp(&b.1));
+                                return output;
+                            }
+                        }
+
+                        match &flat.1 {
+                            FlatShape::Custom(decl_id) => {
+                                //let prefix = working_set.get_span_contents(flat.0).to_vec();
+
+                                let mut stack = Stack::new();
+                                // Set up our initial config to start from
+                                if let Some(conf) = &self.config {
+                                    stack.vars.insert(CONFIG_VARIABLE_ID, conf.clone());
+                                } else {
+                                    stack.vars.insert(
+                                        CONFIG_VARIABLE_ID,
+                                        Value::Record {
+                                            cols: vec![],
+                                            vals: vec![],
+                                            span: Span { start: 0, end: 0 },
+                                        },
+                                    );
+                                }
+
+                                let result = eval_call(
+                                    &self.engine_state,
+                                    &mut stack,
+                                    &Call {
+                                        decl_id: *decl_id,
+                                        head: new_span,
+                                        positional: vec![],
+                                        named: vec![],
+                                        redirect_stdout: true,
+                                        redirect_stderr: true,
+                                    },
+                                    PipelineData::new(new_span),
+                                );
+
+                                fn map_completions<'a>(
+                                    list: impl Iterator<Item = &'a Value>,
+                                    new_span: Span,
+                                    offset: usize,
+                                ) -> Vec<(reedline::Span, String)> {
+                                    list.filter_map(move |x| {
+                                        let s = x.as_string();
+
+                                        match s {
+                                            Ok(s) => Some((
+                                                reedline::Span {
+                                                    start: new_span.start - offset,
+                                                    end: new_span.end - offset,
+                                                },
+                                                s,
+                                            )),
+                                            Err(_) => None,
+                                        }
+                                    })
+                                    .collect()
+                                }
+
+                                let (completions, options) = match result {
+                                    Ok(pd) => {
+                                        let value = pd.into_value(new_span);
+                                        match &value {
+                                            Value::Record { .. } => {
+                                                let completions = value
+                                                    .get_data_by_key("completions")
+                                                    .and_then(|val| {
+                                                        val.as_list().ok().map(|it| {
+                                                            map_completions(
+                                                                it.iter(),
+                                                                new_span,
+                                                                offset,
+                                                            )
+                                                        })
+                                                    })
+                                                    .unwrap_or_default();
+                                                let options = value.get_data_by_key("options");
+
+                                                let options =
+                                                    if let Some(Value::Record { .. }) = &options {
+                                                        let options = options.unwrap_or_default();
+                                                        CompletionOptions {
+                                                            case_sensitive: options
+                                                                .get_data_by_key("case_sensitive")
+                                                                .and_then(|val| val.as_bool().ok())
+                                                                .unwrap_or(true),
+                                                            positional: options
+                                                                .get_data_by_key("positional")
+                                                                .and_then(|val| val.as_bool().ok())
+                                                                .unwrap_or(true),
+                                                            sort: options
+                                                                .get_data_by_key("sort")
+                                                                .and_then(|val| val.as_bool().ok())
+                                                                .unwrap_or(true),
+                                                        }
+                                                    } else {
+                                                        CompletionOptions::default()
+                                                    };
+
+                                                (completions, options)
+                                            }
+                                            Value::List { vals, .. } => {
+                                                let completions =
+                                                    map_completions(vals.iter(), new_span, offset);
+                                                (completions, CompletionOptions::default())
+                                            }
+                                            _ => (vec![], CompletionOptions::default()),
+                                        }
+                                    }
+                                    _ => (vec![], CompletionOptions::default()),
+                                };
+
+                                let mut completions: Vec<(reedline::Span, String)> = completions
+                                    .into_iter()
+                                    .filter(|it| {
+                                        // Minimise clones for new functionality
+                                        match (options.case_sensitive, options.positional) {
+                                            (true, true) => it.1.as_bytes().starts_with(&prefix),
+                                            (true, false) => it.1.contains(
+                                                std::str::from_utf8(&prefix).unwrap_or(""),
+                                            ),
+                                            (false, positional) => {
+                                                let value = it.1.to_lowercase();
+                                                let prefix = std::str::from_utf8(&prefix)
+                                                    .unwrap_or("")
+                                                    .to_lowercase();
+                                                if positional {
+                                                    value.starts_with(&prefix)
+                                                } else {
+                                                    value.contains(&prefix)
+                                                }
+                                            }
+                                        }
+                                    })
+                                    .collect();
+
+                                if options.sort {
+                                    completions.sort_by(|a, b| a.1.cmp(&b.1));
+                                }
+
+                                return completions;
+                            }
+                            FlatShape::Filepath | FlatShape::GlobPattern => {
+                                let cwd = if let Some(d) = self.engine_state.env_vars.get("PWD") {
+                                    match d.as_string() {
+                                        Ok(s) => s,
+                                        Err(_) => "".to_string(),
+                                    }
+                                } else {
+                                    "".to_string()
+                                };
+                                let prefix = String::from_utf8_lossy(&prefix).to_string();
+                                let mut output: Vec<_> =
+                                    file_path_completion(new_span, &prefix, &cwd)
+                                        .into_iter()
+                                        .map(move |x| {
+                                            (
+                                                reedline::Span {
+                                                    start: x.0.start - offset,
+                                                    end: x.0.end - offset,
+                                                },
+                                                x.1,
+                                            )
+                                        })
+                                        .collect();
+                                output.sort_by(|a, b| a.1.cmp(&b.1));
+                                return output;
+                            }
+                            flat_shape => {
+                                let last = flattened
+                                    .iter()
+                                    .rev()
+                                    .skip_while(|x| x.0.end > pos)
+                                    .take_while(|x| {
+                                        matches!(
+                                            x.1,
+                                            FlatShape::InternalCall
+                                                | FlatShape::External
+                                                | FlatShape::ExternalArg
+                                                | FlatShape::Literal
+                                                | FlatShape::String
+                                        )
+                                    })
+                                    .last();
+
+                                // The last item here would be the earliest shape that could possible by part of this subcommand
+                                let subcommands = if let Some(last) = last {
+                                    self.complete_commands(
+                                        &working_set,
+                                        Span {
+                                            start: last.0.start,
+                                            end: pos,
+                                        },
+                                        offset,
+                                        false,
+                                    )
+                                } else {
+                                    vec![]
+                                };
+
+                                if !subcommands.is_empty() {
+                                    return subcommands;
+                                }
+
+                                let commands =
+                                    if matches!(flat_shape, nu_parser::FlatShape::External)
+                                        || matches!(flat_shape, nu_parser::FlatShape::InternalCall)
+                                        || ((new_span.end - new_span.start) == 0)
+                                    {
+                                        // we're in a gap or at a command
+                                        self.complete_commands(&working_set, new_span, offset, true)
+                                    } else {
+                                        vec![]
+                                    };
+
+                                let cwd = if let Some(d) = self.engine_state.env_vars.get("PWD") {
+                                    match d.as_string() {
+                                        Ok(s) => s,
+                                        Err(_) => "".to_string(),
+                                    }
+                                } else {
+                                    "".to_string()
+                                };
+
+                                let preceding_byte = if new_span.start > offset {
+                                    working_set
+                                        .get_span_contents(Span {
+                                            start: new_span.start - 1,
+                                            end: new_span.start,
+                                        })
+                                        .to_vec()
+                                } else {
+                                    vec![]
+                                };
+                                // let prefix = working_set.get_span_contents(flat.0);
+                                let prefix = String::from_utf8_lossy(&prefix).to_string();
+                                let mut output = file_path_completion(new_span, &prefix, &cwd)
+                                    .into_iter()
+                                    .map(move |x| {
+                                        if flat_idx == 0 {
+                                            // We're in the command position
+                                            if x.1.starts_with('"')
+                                                && !matches!(preceding_byte.get(0), Some(b'^'))
+                                            {
+                                                let trimmed = trim_quotes(x.1.as_bytes());
+                                                let trimmed =
+                                                    String::from_utf8_lossy(trimmed).to_string();
+                                                let expanded =
+                                                    nu_path::canonicalize_with(trimmed, &cwd);
+
+                                                if let Ok(expanded) = expanded {
+                                                    if is_executable::is_executable(expanded) {
+                                                        (x.0, format!("^{}", x.1))
+                                                    } else {
+                                                        (x.0, x.1)
+                                                    }
+                                                } else {
+                                                    (x.0, x.1)
+                                                }
+                                            } else {
+                                                (x.0, x.1)
+                                            }
+                                        } else {
+                                            (x.0, x.1)
+                                        }
+                                    })
+                                    .map(move |x| {
+                                        (
+                                            reedline::Span {
+                                                start: x.0.start - offset,
+                                                end: x.0.end - offset,
+                                            },
+                                            x.1,
+                                        )
+                                    })
+                                    .chain(subcommands.into_iter())
+                                    .chain(commands.into_iter())
+                                    .collect::<Vec<_>>();
+                                //output.dedup_by(|a, b| a.1 == b.1);
+                                output.sort_by(|a, b| a.1.cmp(&b.1));
+
+                                return output;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        vec![]
+    }
+}
+
+impl Completer for NuCompleter {
+    fn complete(&self, line: &str, pos: usize) -> Vec<(reedline::Span, String)> {
+        self.completion_helper(line, pos)
+    }
+}
+
+fn file_path_completion(
+    span: nu_protocol::Span,
+    partial: &str,
+    cwd: &str,
+) -> Vec<(nu_protocol::Span, String)> {
+    use std::path::{is_separator, Path};
+
+    let partial = partial.replace('\'', "");
+
+    let (base_dir_name, partial) = {
+        // If partial is only a word we want to search in the current dir
+        let (base, rest) = partial.rsplit_once(is_separator).unwrap_or((".", &partial));
+        // On windows, this standardizes paths to use \
+        let mut base = base.replace(is_separator, &SEP.to_string());
+
+        // rsplit_once removes the separator
+        base.push(SEP);
+        (base, rest)
+    };
+
+    let base_dir = nu_path::expand_path_with(&base_dir_name, cwd);
+    // This check is here as base_dir.read_dir() with base_dir == "" will open the current dir
+    // which we don't want in this case (if we did, base_dir would already be ".")
+    if base_dir == Path::new("") {
+        return Vec::new();
+    }
+
+    if let Ok(result) = base_dir.read_dir() {
+        result
+            .filter_map(|entry| {
+                entry.ok().and_then(|entry| {
+                    let mut file_name = entry.file_name().to_string_lossy().into_owned();
+                    if matches(partial, &file_name) {
+                        let mut path = format!("{}{}", base_dir_name, file_name);
+                        if entry.path().is_dir() {
+                            path.push(SEP);
+                            file_name.push(SEP);
+                        }
+
+                        if path.contains(' ') {
+                            path = format!("\'{}\'", path);
+                        }
+
+                        Some((span, path))
+                    } else {
+                        None
+                    }
+                })
+            })
+            .collect()
+    } else {
+        Vec::new()
+    }
+}
+
+fn matches(partial: &str, from: &str) -> bool {
+    from.to_ascii_lowercase()
+        .starts_with(&partial.to_ascii_lowercase())
+}

crates/nu-cli/src/config_files.rs

@@ -0,0 +1,84 @@
+use crate::util::{eval_source, report_error};
+#[cfg(feature = "plugin")]
+use log::info;
+use nu_protocol::engine::{EngineState, Stack, StateDelta, StateWorkingSet};
+use nu_protocol::{PipelineData, Span};
+use std::path::PathBuf;
+
+#[cfg(feature = "plugin")]
+const PLUGIN_FILE: &str = "plugin.nu";
+
+#[cfg(feature = "plugin")]
+pub fn read_plugin_file(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    storage_path: &str,
+    is_perf_true: bool,
+) {
+    // Reading signatures from signature file
+    // The plugin.nu file stores the parsed signature collected from each registered plugin
+    add_plugin_file(engine_state, storage_path);
+
+    let plugin_path = engine_state.plugin_signatures.clone();
+    if let Some(plugin_path) = plugin_path {
+        let plugin_filename = plugin_path.to_string_lossy().to_owned();
+
+        if let Ok(contents) = std::fs::read(&plugin_path) {
+            eval_source(
+                engine_state,
+                stack,
+                &contents,
+                &plugin_filename,
+                PipelineData::new(Span::new(0, 0)),
+            );
+        }
+    }
+
+    if is_perf_true {
+        info!("read_plugin_file {}:{}:{}", file!(), line!(), column!());
+    }
+}
+
+#[cfg(feature = "plugin")]
+pub fn add_plugin_file(engine_state: &mut EngineState, storage_path: &str) {
+    if let Some(mut plugin_path) = nu_path::config_dir() {
+        // Path to store plugins signatures
+        plugin_path.push(storage_path);
+        plugin_path.push(PLUGIN_FILE);
+        engine_state.plugin_signatures = Some(plugin_path.clone());
+    }
+}
+
+pub fn eval_config_contents(
+    config_path: PathBuf,
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+) {
+    if config_path.exists() & config_path.is_file() {
+        let config_filename = config_path.to_string_lossy().to_owned();
+
+        if let Ok(contents) = std::fs::read(&config_path) {
+            eval_source(
+                engine_state,
+                stack,
+                &contents,
+                &config_filename,
+                PipelineData::new(Span::new(0, 0)),
+            );
+
+            // Merge the delta in case env vars changed in the config
+            match nu_engine::env::current_dir(engine_state, stack) {
+                Ok(cwd) => {
+                    if let Err(e) = engine_state.merge_delta(StateDelta::new(), Some(stack), cwd) {
+                        let working_set = StateWorkingSet::new(engine_state);
+                        report_error(&working_set, &e);
+                    }
+                }
+                Err(e) => {
+                    let working_set = StateWorkingSet::new(engine_state);
+                    report_error(&working_set, &e);
+                }
+            }
+        }
+    }
+}

crates/nu-cli/src/errors.rs

@@ -0,0 +1,54 @@
+use miette::{LabeledSpan, MietteHandler, ReportHandler, Severity, SourceCode};
+use nu_protocol::engine::StateWorkingSet;
+use thiserror::Error;
+
+/// This error exists so that we can defer SourceCode handling. It simply
+/// forwards most methods, except for `.source_code()`, which we provide.
+#[derive(Error)]
+#[error("{0}")]
+pub struct CliError<'src>(
+    pub &'src (dyn miette::Diagnostic + Send + Sync + 'static),
+    pub &'src StateWorkingSet<'src>,
+);
+
+impl std::fmt::Debug for CliError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        MietteHandler::default().debug(self, f)?;
+        Ok(())
+    }
+}
+
+impl<'src> miette::Diagnostic for CliError<'src> {
+    fn code<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
+        self.0.code()
+    }
+
+    fn severity(&self) -> Option<Severity> {
+        self.0.severity()
+    }
+
+    fn help<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
+        self.0.help()
+    }
+
+    fn url<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
+        self.0.url()
+    }
+
+    fn labels<'a>(&'a self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + 'a>> {
+        self.0.labels()
+    }
+
+    // Finally, we redirect the source_code method to our own source.
+    fn source_code(&self) -> Option<&dyn SourceCode> {
+        if let Some(source_code) = self.0.source_code() {
+            Some(source_code)
+        } else {
+            Some(&self.1)
+        }
+    }
+
+    fn related<'a>(&'a self) -> Option<Box<dyn Iterator<Item = &'a dyn miette::Diagnostic> + 'a>> {
+        self.0.related()
+    }
+}

crates/nu-cli/src/eval_file.rs

@@ -0,0 +1,145 @@
+use crate::util::{eval_source, report_error};
+use log::info;
+use log::trace;
+use miette::{IntoDiagnostic, Result};
+use nu_engine::convert_env_values;
+use nu_parser::parse;
+use nu_protocol::{
+    ast::Call,
+    engine::{EngineState, Stack, StateWorkingSet},
+    Config, PipelineData, Span, Value,
+};
+use std::io::Write;
+
+/// Main function used when a file path is found as argument for nu
+pub fn evaluate_file(
+    path: String,
+    args: &[String],
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    input: PipelineData,
+    is_perf_true: bool,
+) -> Result<()> {
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+        std::process::exit(1);
+    }
+
+    // Make a note of the exceptions we see for externals that look like math expressions
+    let exceptions = crate::util::external_exceptions(engine_state, stack);
+    engine_state.external_exceptions = exceptions;
+
+    let file = std::fs::read(&path).into_diagnostic()?;
+
+    let mut working_set = StateWorkingSet::new(engine_state);
+    trace!("parsing file: {}", path);
+
+    let _ = parse(&mut working_set, Some(&path), &file, false, &[]);
+
+    if working_set.find_decl(b"main").is_some() {
+        let args = format!("main {}", args.join(" "));
+
+        if !eval_source(
+            engine_state,
+            stack,
+            &file,
+            &path,
+            PipelineData::new(Span::new(0, 0)),
+        ) {
+            std::process::exit(1);
+        }
+        if !eval_source(engine_state, stack, args.as_bytes(), "<commandline>", input) {
+            std::process::exit(1);
+        }
+    } else if !eval_source(engine_state, stack, &file, &path, input) {
+        std::process::exit(1);
+    }
+
+    if is_perf_true {
+        info!("evaluate {}:{}:{}", file!(), line!(), column!());
+    }
+
+    Ok(())
+}
+
+pub fn print_table_or_error(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    mut pipeline_data: PipelineData,
+    config: &Config,
+) {
+    let exit_code = match &mut pipeline_data {
+        PipelineData::ExternalStream { exit_code, .. } => exit_code.take(),
+        _ => None,
+    };
+
+    match engine_state.find_decl("table".as_bytes()) {
+        Some(decl_id) => {
+            let table = engine_state.get_decl(decl_id).run(
+                engine_state,
+                stack,
+                &Call::new(Span::new(0, 0)),
+                pipeline_data,
+            );
+
+            match table {
+                Ok(table) => {
+                    for item in table {
+                        let stdout = std::io::stdout();
+
+                        if let Value::Error { error } = item {
+                            let working_set = StateWorkingSet::new(engine_state);
+
+                            report_error(&working_set, &error);
+
+                            std::process::exit(1);
+                        }
+
+                        let mut out = item.into_string("\n", config);
+                        out.push('\n');
+
+                        match stdout.lock().write_all(out.as_bytes()) {
+                            Ok(_) => (),
+                            Err(err) => eprintln!("{}", err),
+                        };
+                    }
+                }
+                Err(error) => {
+                    let working_set = StateWorkingSet::new(engine_state);
+
+                    report_error(&working_set, &error);
+
+                    std::process::exit(1);
+                }
+            }
+        }
+        None => {
+            for item in pipeline_data {
+                let stdout = std::io::stdout();
+
+                if let Value::Error { error } = item {
+                    let working_set = StateWorkingSet::new(engine_state);
+
+                    report_error(&working_set, &error);
+
+                    std::process::exit(1);
+                }
+
+                let mut out = item.into_string("\n", config);
+                out.push('\n');
+
+                match stdout.lock().write_all(out.as_bytes()) {
+                    Ok(_) => (),
+                    Err(err) => eprintln!("{}", err),
+                };
+            }
+        }
+    };
+
+    // Make sure everything has finished
+    if let Some(exit_code) = exit_code {
+        let _: Vec<_> = exit_code.into_iter().collect();
+    }
+}

crates/nu-cli/src/lib.rs

@@ -0,0 +1,33 @@
+mod commands;
+mod completions;
+mod config_files;
+mod errors;
+mod eval_file;
+mod nu_highlight;
+mod print;
+mod prompt;
+mod prompt_update;
+mod reedline_config;
+mod repl;
+mod syntax_highlight;
+mod util;
+mod validation;
+
+pub use commands::evaluate_commands;
+pub use completions::NuCompleter;
+pub use config_files::eval_config_contents;
+pub use errors::CliError;
+pub use eval_file::evaluate_file;
+pub use nu_highlight::NuHighlight;
+pub use print::Print;
+pub use prompt::NushellPrompt;
+pub use repl::evaluate_repl;
+pub use syntax_highlight::NuHighlighter;
+pub use util::print_pipeline_data;
+pub use util::{eval_source, gather_parent_env_vars, get_init_cwd, report_error};
+pub use validation::NuValidator;
+
+#[cfg(feature = "plugin")]
+pub use config_files::add_plugin_file;
+#[cfg(feature = "plugin")]
+pub use config_files::read_plugin_file;

crates/nu-cli/src/nu_highlight.rs

@@ -0,0 +1,63 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Value};
+use reedline::Highlighter;
+
+#[derive(Clone)]
+pub struct NuHighlight;
+
+impl Command for NuHighlight {
+    fn name(&self) -> &str {
+        "nu-highlight"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("nu-highlight").category(Category::Strings)
+    }
+
+    fn usage(&self) -> &str {
+        "Syntax highlight the input string."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+
+        let ctrlc = engine_state.ctrlc.clone();
+        let engine_state = engine_state.clone();
+        let config = stack.get_config()?;
+
+        let highlighter = crate::NuHighlighter {
+            engine_state,
+            config,
+        };
+
+        input.map(
+            move |x| match x.as_string() {
+                Ok(line) => {
+                    let highlights = highlighter.highlight(&line, line.len());
+
+                    Value::String {
+                        val: highlights.render_simple(),
+                        span: head,
+                    }
+                }
+                Err(err) => Value::Error { error: err },
+            },
+            ctrlc,
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Describe the type of a string",
+            example: "'let x = 3' | nu-highlight",
+            result: None,
+        }]
+    }
+}

crates/nu-cli/src/print.rs

@@ -0,0 +1,57 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Value,
+};
+
+#[derive(Clone)]
+pub struct Print;
+
+impl Command for Print {
+    fn name(&self) -> &str {
+        "print"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("print")
+            .rest("rest", SyntaxShape::Any, "the values to print")
+            .category(Category::Strings)
+    }
+
+    fn usage(&self) -> &str {
+        "Prints the values given"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let args: Vec<Value> = call.rest(engine_state, stack, 0)?;
+        let head = call.head;
+
+        for arg in args {
+            crate::util::print_pipeline_data(arg.into_pipeline_data(), engine_state, stack)?;
+        }
+
+        Ok(PipelineData::new(head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Print 'hello world'",
+                example: r#"print "hello world""#,
+                result: None,
+            },
+            Example {
+                description: "Print the sum of 2 and 3",
+                example: r#"print (2 + 3)"#,
+                result: None,
+            },
+        ]
+    }
+}

crates/nu-cli/src/prompt.rs

@@ -0,0 +1,143 @@
+use reedline::DefaultPrompt;
+
+use {
+    reedline::{
+        Prompt, PromptEditMode, PromptHistorySearch, PromptHistorySearchStatus, PromptViMode,
+    },
+    std::borrow::Cow,
+};
+
+/// Nushell prompt definition
+#[derive(Clone)]
+pub struct NushellPrompt {
+    left_prompt_string: Option<String>,
+    right_prompt_string: Option<String>,
+    default_prompt_indicator: String,
+    default_vi_insert_prompt_indicator: String,
+    default_vi_normal_prompt_indicator: String,
+    default_multiline_indicator: String,
+}
+
+impl Default for NushellPrompt {
+    fn default() -> Self {
+        NushellPrompt::new()
+    }
+}
+
+impl NushellPrompt {
+    pub fn new() -> NushellPrompt {
+        NushellPrompt {
+            left_prompt_string: None,
+            right_prompt_string: None,
+            default_prompt_indicator: "〉".to_string(),
+            default_vi_insert_prompt_indicator: ": ".to_string(),
+            default_vi_normal_prompt_indicator: "〉".to_string(),
+            default_multiline_indicator: "::: ".to_string(),
+        }
+    }
+
+    pub fn update_prompt_left(&mut self, prompt_string: Option<String>) {
+        self.left_prompt_string = prompt_string;
+    }
+
+    pub fn update_prompt_right(&mut self, prompt_string: Option<String>) {
+        self.right_prompt_string = prompt_string;
+    }
+
+    pub fn update_prompt_indicator(&mut self, prompt_indicator_string: String) {
+        self.default_prompt_indicator = prompt_indicator_string;
+    }
+
+    pub fn update_prompt_vi_insert(&mut self, prompt_vi_insert_string: String) {
+        self.default_vi_insert_prompt_indicator = prompt_vi_insert_string;
+    }
+
+    pub fn update_prompt_vi_normal(&mut self, prompt_vi_normal_string: String) {
+        self.default_vi_normal_prompt_indicator = prompt_vi_normal_string;
+    }
+
+    pub fn update_prompt_multiline(&mut self, prompt_multiline_indicator_string: String) {
+        self.default_multiline_indicator = prompt_multiline_indicator_string;
+    }
+
+    pub fn update_all_prompt_strings(
+        &mut self,
+        left_prompt_string: Option<String>,
+        right_prompt_string: Option<String>,
+        prompt_indicator_string: String,
+        prompt_multiline_indicator_string: String,
+        prompt_vi: (String, String),
+    ) {
+        let (prompt_vi_insert_string, prompt_vi_normal_string) = prompt_vi;
+
+        self.left_prompt_string = left_prompt_string;
+        self.right_prompt_string = right_prompt_string;
+        self.default_prompt_indicator = prompt_indicator_string;
+        self.default_vi_insert_prompt_indicator = prompt_vi_insert_string;
+        self.default_vi_normal_prompt_indicator = prompt_vi_normal_string;
+        self.default_multiline_indicator = prompt_multiline_indicator_string;
+    }
+
+    fn default_wrapped_custom_string(&self, str: String) -> String {
+        format!("({})", str)
+    }
+}
+
+impl Prompt for NushellPrompt {
+    fn render_prompt_left(&self) -> Cow<str> {
+        if let Some(prompt_string) = &self.left_prompt_string {
+            prompt_string.replace('\n', "\r\n").into()
+        } else {
+            let default = DefaultPrompt::new();
+            default
+                .render_prompt_left()
+                .to_string()
+                .replace('\n', "\r\n")
+                .into()
+        }
+    }
+
+    fn render_prompt_right(&self) -> Cow<str> {
+        if let Some(prompt_string) = &self.right_prompt_string {
+            prompt_string.replace('\n', "\r\n").into()
+        } else {
+            let default = DefaultPrompt::new();
+            default
+                .render_prompt_right()
+                .to_string()
+                .replace('\n', "\r\n")
+                .into()
+        }
+    }
+
+    fn render_prompt_indicator(&self, edit_mode: PromptEditMode) -> Cow<str> {
+        match edit_mode {
+            PromptEditMode::Default => self.default_prompt_indicator.as_str().into(),
+            PromptEditMode::Emacs => self.default_prompt_indicator.as_str().into(),
+            PromptEditMode::Vi(vi_mode) => match vi_mode {
+                PromptViMode::Normal => self.default_vi_normal_prompt_indicator.as_str().into(),
+                PromptViMode::Insert => self.default_vi_insert_prompt_indicator.as_str().into(),
+            },
+            PromptEditMode::Custom(str) => self.default_wrapped_custom_string(str).into(),
+        }
+    }
+
+    fn render_prompt_multiline_indicator(&self) -> Cow<str> {
+        Cow::Borrowed(self.default_multiline_indicator.as_str())
+    }
+
+    fn render_prompt_history_search_indicator(
+        &self,
+        history_search: PromptHistorySearch,
+    ) -> Cow<str> {
+        let prefix = match history_search.status {
+            PromptHistorySearchStatus::Passing => "",
+            PromptHistorySearchStatus::Failing => "failing ",
+        };
+
+        Cow::Owned(format!(
+            "({}reverse-search: {})",
+            prefix, history_search.term
+        ))
+    }
+}

crates/nu-cli/src/prompt_update.rs

@@ -0,0 +1,193 @@
+use crate::util::report_error;
+use crate::NushellPrompt;
+use log::info;
+use nu_engine::eval_subexpression;
+use nu_parser::parse;
+use nu_protocol::{
+    engine::{EngineState, Stack, StateWorkingSet},
+    Config, PipelineData, Span, Value,
+};
+use reedline::Prompt;
+
+// Name of environment variable where the prompt could be stored
+pub(crate) const PROMPT_COMMAND: &str = "PROMPT_COMMAND";
+pub(crate) const PROMPT_COMMAND_RIGHT: &str = "PROMPT_COMMAND_RIGHT";
+pub(crate) const PROMPT_INDICATOR: &str = "PROMPT_INDICATOR";
+pub(crate) const PROMPT_INDICATOR_VI_INSERT: &str = "PROMPT_INDICATOR_VI_INSERT";
+pub(crate) const PROMPT_INDICATOR_VI_NORMAL: &str = "PROMPT_INDICATOR_VI_NORMAL";
+pub(crate) const PROMPT_MULTILINE_INDICATOR: &str = "PROMPT_MULTILINE_INDICATOR";
+
+pub(crate) fn get_prompt_indicators(
+    config: &Config,
+    engine_state: &EngineState,
+    stack: &Stack,
+    is_perf_true: bool,
+) -> (String, String, String, String) {
+    let prompt_indicator = match stack.get_env_var(engine_state, PROMPT_INDICATOR) {
+        Some(pi) => pi.into_string("", config),
+        None => "〉".to_string(),
+    };
+
+    let prompt_vi_insert = match stack.get_env_var(engine_state, PROMPT_INDICATOR_VI_INSERT) {
+        Some(pvii) => pvii.into_string("", config),
+        None => ": ".to_string(),
+    };
+
+    let prompt_vi_normal = match stack.get_env_var(engine_state, PROMPT_INDICATOR_VI_NORMAL) {
+        Some(pviv) => pviv.into_string("", config),
+        None => "〉".to_string(),
+    };
+
+    let prompt_multiline = match stack.get_env_var(engine_state, PROMPT_MULTILINE_INDICATOR) {
+        Some(pm) => pm.into_string("", config),
+        None => "::: ".to_string(),
+    };
+
+    if is_perf_true {
+        info!(
+            "get_prompt_indicators {}:{}:{}",
+            file!(),
+            line!(),
+            column!()
+        );
+    }
+
+    (
+        prompt_indicator,
+        prompt_vi_insert,
+        prompt_vi_normal,
+        prompt_multiline,
+    )
+}
+
+fn get_prompt_string(
+    prompt: &str,
+    config: &Config,
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    is_perf_true: bool,
+) -> Option<String> {
+    stack
+        .get_env_var(engine_state, prompt)
+        .and_then(|v| match v {
+            Value::Block {
+                val: block_id,
+                captures,
+                ..
+            } => {
+                let block = engine_state.get_block(block_id);
+                let mut stack = stack.captures_to_stack(&captures);
+                // Use eval_subexpression to force a redirection of output, so we can use everything in prompt
+                let ret_val = eval_subexpression(
+                    engine_state,
+                    &mut stack,
+                    block,
+                    PipelineData::new(Span::new(0, 0)), // Don't try this at home, 0 span is ignored
+                );
+                if is_perf_true {
+                    info!(
+                        "get_prompt_string (block) {}:{}:{}",
+                        file!(),
+                        line!(),
+                        column!()
+                    );
+                }
+
+                match ret_val {
+                    Ok(ret_val) => Some(ret_val),
+                    Err(err) => {
+                        let working_set = StateWorkingSet::new(engine_state);
+                        report_error(&working_set, &err);
+                        None
+                    }
+                }
+            }
+            Value::String { val: source, .. } => {
+                let mut working_set = StateWorkingSet::new(engine_state);
+                let (block, _) = parse(&mut working_set, None, source.as_bytes(), true, &[]);
+                // Use eval_subexpression to force a redirection of output, so we can use everything in prompt
+                let ret_val = eval_subexpression(
+                    engine_state,
+                    stack,
+                    &block,
+                    PipelineData::new(Span::new(0, 0)), // Don't try this at home, 0 span is ignored
+                )
+                .ok();
+                if is_perf_true {
+                    info!(
+                        "get_prompt_string (string) {}:{}:{}",
+                        file!(),
+                        line!(),
+                        column!()
+                    );
+                }
+
+                ret_val
+            }
+            _ => None,
+        })
+        .and_then(|pipeline_data| {
+            let output = pipeline_data.collect_string("", config).ok();
+
+            match output {
+                Some(mut x) => {
+                    // Just remove the very last newline.
+                    if x.ends_with('\n') {
+                        x.pop();
+                    }
+
+                    if x.ends_with('\r') {
+                        x.pop();
+                    }
+                    Some(x)
+                }
+                None => None,
+            }
+        })
+}
+
+pub(crate) fn update_prompt<'prompt>(
+    config: &Config,
+    engine_state: &EngineState,
+    stack: &Stack,
+    nu_prompt: &'prompt mut NushellPrompt,
+    is_perf_true: bool,
+) -> &'prompt dyn Prompt {
+    // get the other indicators
+    let (
+        prompt_indicator_string,
+        prompt_vi_insert_string,
+        prompt_vi_normal_string,
+        prompt_multiline_string,
+    ) = get_prompt_indicators(config, engine_state, stack, is_perf_true);
+
+    let mut stack = stack.clone();
+
+    // apply the other indicators
+    nu_prompt.update_all_prompt_strings(
+        get_prompt_string(
+            PROMPT_COMMAND,
+            config,
+            engine_state,
+            &mut stack,
+            is_perf_true,
+        ),
+        get_prompt_string(
+            PROMPT_COMMAND_RIGHT,
+            config,
+            engine_state,
+            &mut stack,
+            is_perf_true,
+        ),
+        prompt_indicator_string,
+        prompt_multiline_string,
+        (prompt_vi_insert_string, prompt_vi_normal_string),
+    );
+
+    let ret_val = nu_prompt as &dyn Prompt;
+    if is_perf_true {
+        info!("update_prompt {}:{}:{}", file!(), line!(), column!());
+    }
+
+    ret_val
+}

crates/nu-cli/src/reedline_config.rs

@@ -0,0 +1,781 @@
+use crossterm::event::{KeyCode, KeyModifiers};
+use nu_color_config::lookup_ansi_color_style;
+use nu_protocol::{extract_value, Config, ParsedKeybinding, ShellError, Span, Value};
+use reedline::{
+    default_emacs_keybindings, default_vi_insert_keybindings, default_vi_normal_keybindings,
+    CompletionMenu, EditCommand, HistoryMenu, Keybindings, Reedline, ReedlineEvent,
+};
+
+// Creates an input object for the completion menu based on the dictionary
+// stored in the config variable
+pub(crate) fn add_completion_menu(line_editor: Reedline, config: &Config) -> Reedline {
+    let mut completion_menu = CompletionMenu::default();
+
+    completion_menu = match config
+        .menu_config
+        .get("columns")
+        .and_then(|value| value.as_integer().ok())
+    {
+        Some(value) => completion_menu.with_columns(value as u16),
+        None => completion_menu,
+    };
+
+    completion_menu = completion_menu.with_column_width(
+        config
+            .menu_config
+            .get("col_width")
+            .and_then(|value| value.as_integer().ok())
+            .map(|value| value as usize),
+    );
+
+    completion_menu = match config
+        .menu_config
+        .get("col_padding")
+        .and_then(|value| value.as_integer().ok())
+    {
+        Some(value) => completion_menu.with_column_padding(value as usize),
+        None => completion_menu,
+    };
+
+    completion_menu = match config
+        .menu_config
+        .get("text_style")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => completion_menu.with_text_style(lookup_ansi_color_style(&value)),
+        None => completion_menu,
+    };
+
+    completion_menu = match config
+        .menu_config
+        .get("selected_text_style")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => completion_menu.with_selected_text_style(lookup_ansi_color_style(&value)),
+        None => completion_menu,
+    };
+
+    completion_menu = match config
+        .menu_config
+        .get("marker")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => completion_menu.with_marker(value),
+        None => completion_menu,
+    };
+
+    line_editor.with_menu(Box::new(completion_menu))
+}
+
+// Creates an input object for the history menu based on the dictionary
+// stored in the config variable
+pub(crate) fn add_history_menu(line_editor: Reedline, config: &Config) -> Reedline {
+    let mut history_menu = HistoryMenu::default();
+
+    history_menu = match config
+        .history_config
+        .get("page_size")
+        .and_then(|value| value.as_integer().ok())
+    {
+        Some(value) => history_menu.with_page_size(value as usize),
+        None => history_menu,
+    };
+
+    history_menu = match config
+        .history_config
+        .get("selector")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => {
+            let char = value.chars().next().unwrap_or('!');
+            history_menu.with_selection_char(char)
+        }
+        None => history_menu,
+    };
+
+    history_menu = match config
+        .history_config
+        .get("text_style")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => history_menu.with_text_style(lookup_ansi_color_style(&value)),
+        None => history_menu,
+    };
+
+    history_menu = match config
+        .history_config
+        .get("selected_text_style")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => history_menu.with_selected_text_style(lookup_ansi_color_style(&value)),
+        None => history_menu,
+    };
+
+    history_menu = match config
+        .history_config
+        .get("marker")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => history_menu.with_marker(value),
+        None => history_menu,
+    };
+
+    line_editor.with_menu(Box::new(history_menu))
+}
+
+fn add_menu_keybindings(keybindings: &mut Keybindings) {
+    keybindings.add_binding(
+        KeyModifiers::CONTROL,
+        KeyCode::Char('x'),
+        ReedlineEvent::UntilFound(vec![
+            ReedlineEvent::Menu("history_menu".to_string()),
+            ReedlineEvent::MenuPageNext,
+        ]),
+    );
+
+    keybindings.add_binding(
+        KeyModifiers::CONTROL,
+        KeyCode::Char('z'),
+        ReedlineEvent::UntilFound(vec![
+            ReedlineEvent::MenuPagePrevious,
+            ReedlineEvent::Edit(vec![EditCommand::Undo]),
+        ]),
+    );
+
+    keybindings.add_binding(
+        KeyModifiers::NONE,
+        KeyCode::Tab,
+        ReedlineEvent::UntilFound(vec![
+            ReedlineEvent::Menu("completion_menu".to_string()),
+            ReedlineEvent::MenuNext,
+        ]),
+    );
+
+    keybindings.add_binding(
+        KeyModifiers::SHIFT,
+        KeyCode::BackTab,
+        ReedlineEvent::MenuPrevious,
+    );
+}
+
+pub enum KeybindingsMode {
+    Emacs(Keybindings),
+    Vi {
+        insert_keybindings: Keybindings,
+        normal_keybindings: Keybindings,
+    },
+}
+
+pub(crate) fn create_keybindings(config: &Config) -> Result<KeybindingsMode, ShellError> {
+    let parsed_keybindings = &config.keybindings;
+
+    let mut emacs_keybindings = default_emacs_keybindings();
+    let mut insert_keybindings = default_vi_insert_keybindings();
+    let mut normal_keybindings = default_vi_normal_keybindings();
+
+    for keybinding in parsed_keybindings {
+        add_keybinding(
+            &keybinding.mode,
+            keybinding,
+            config,
+            &mut emacs_keybindings,
+            &mut insert_keybindings,
+            &mut normal_keybindings,
+        )?
+    }
+
+    match config.edit_mode.as_str() {
+        "emacs" => {
+            add_menu_keybindings(&mut emacs_keybindings);
+
+            Ok(KeybindingsMode::Emacs(emacs_keybindings))
+        }
+        _ => {
+            add_menu_keybindings(&mut insert_keybindings);
+            add_menu_keybindings(&mut normal_keybindings);
+
+            Ok(KeybindingsMode::Vi {
+                insert_keybindings,
+                normal_keybindings,
+            })
+        }
+    }
+}
+
+fn add_keybinding(
+    mode: &Value,
+    keybinding: &ParsedKeybinding,
+    config: &Config,
+    emacs_keybindings: &mut Keybindings,
+    insert_keybindings: &mut Keybindings,
+    normal_keybindings: &mut Keybindings,
+) -> Result<(), ShellError> {
+    match &mode {
+        Value::String { val, span } => match val.as_str() {
+            "emacs" => add_parsed_keybinding(emacs_keybindings, keybinding, config),
+            "vi_insert" => add_parsed_keybinding(insert_keybindings, keybinding, config),
+            "vi_normal" => add_parsed_keybinding(normal_keybindings, keybinding, config),
+            m => Err(ShellError::UnsupportedConfigValue(
+                "emacs, vi_insert or vi_normal".to_string(),
+                m.to_string(),
+                *span,
+            )),
+        },
+        Value::List { vals, .. } => {
+            for inner_mode in vals {
+                add_keybinding(
+                    inner_mode,
+                    keybinding,
+                    config,
+                    emacs_keybindings,
+                    insert_keybindings,
+                    normal_keybindings,
+                )?
+            }
+
+            Ok(())
+        }
+        v => Err(ShellError::UnsupportedConfigValue(
+            "string or list of strings".to_string(),
+            v.into_abbreviated_string(config),
+            v.span()?,
+        )),
+    }
+}
+
+fn add_parsed_keybinding(
+    keybindings: &mut Keybindings,
+    keybinding: &ParsedKeybinding,
+    config: &Config,
+) -> Result<(), ShellError> {
+    let modifier = match keybinding
+        .modifier
+        .into_string("", config)
+        .to_lowercase()
+        .as_str()
+    {
+        "control" => KeyModifiers::CONTROL,
+        "shift" => KeyModifiers::SHIFT,
+        "alt" => KeyModifiers::ALT,
+        "none" => KeyModifiers::NONE,
+        "control | shift" => KeyModifiers::CONTROL | KeyModifiers::SHIFT,
+        "control | alt" => KeyModifiers::CONTROL | KeyModifiers::ALT,
+        "control | alt | shift" => KeyModifiers::CONTROL | KeyModifiers::ALT | KeyModifiers::SHIFT,
+        _ => {
+            return Err(ShellError::UnsupportedConfigValue(
+                "CONTROL, SHIFT, ALT or NONE".to_string(),
+                keybinding.modifier.into_abbreviated_string(config),
+                keybinding.modifier.span()?,
+            ))
+        }
+    };
+
+    let keycode = match keybinding
+        .keycode
+        .into_string("", config)
+        .to_lowercase()
+        .as_str()
+    {
+        "backspace" => KeyCode::Backspace,
+        "enter" => KeyCode::Enter,
+        c if c.starts_with("char_") => {
+            let mut char_iter = c.chars().skip(5);
+            let pos1 = char_iter.next();
+            let pos2 = char_iter.next();
+
+            let char = match (pos1, pos2) {
+                (Some(char), None) => Ok(char),
+                _ => Err(ShellError::UnsupportedConfigValue(
+                    "char_<CHAR: unicode codepoint>".to_string(),
+                    c.to_string(),
+                    keybinding.keycode.span()?,
+                )),
+            }?;
+
+            KeyCode::Char(char)
+        }
+        "down" => KeyCode::Down,
+        "up" => KeyCode::Up,
+        "left" => KeyCode::Left,
+        "right" => KeyCode::Right,
+        "home" => KeyCode::Home,
+        "end" => KeyCode::End,
+        "pageup" => KeyCode::PageUp,
+        "pagedown" => KeyCode::PageDown,
+        "tab" => KeyCode::Tab,
+        "backtab" => KeyCode::BackTab,
+        "delete" => KeyCode::Delete,
+        "insert" => KeyCode::Insert,
+        c if c.starts_with('f') => {
+            let fn_num: u8 = c[1..]
+                .parse()
+                .ok()
+                .filter(|num| matches!(num, 1..=12))
+                .ok_or(ShellError::UnsupportedConfigValue(
+                    "(f1|f2|...|f12)".to_string(),
+                    format!("unknown function key: {}", c),
+                    keybinding.keycode.span()?,
+                ))?;
+            KeyCode::F(fn_num)
+        }
+        "null" => KeyCode::Null,
+        "esc" | "escape" => KeyCode::Esc,
+        _ => {
+            return Err(ShellError::UnsupportedConfigValue(
+                "crossterm KeyCode".to_string(),
+                keybinding.keycode.into_abbreviated_string(config),
+                keybinding.keycode.span()?,
+            ))
+        }
+    };
+
+    let event = parse_event(&keybinding.event, config)?;
+
+    keybindings.add_binding(modifier, keycode, event);
+
+    Ok(())
+}
+
+enum EventType<'config> {
+    Send(&'config Value),
+    Edit(&'config Value),
+    Until(&'config Value),
+}
+
+impl<'config> EventType<'config> {
+    fn try_from_columns(
+        cols: &'config [String],
+        vals: &'config [Value],
+        span: &'config Span,
+    ) -> Result<Self, ShellError> {
+        extract_value("send", cols, vals, span)
+            .map(Self::Send)
+            .or_else(|_| extract_value("edit", cols, vals, span).map(Self::Edit))
+            .or_else(|_| extract_value("until", cols, vals, span).map(Self::Until))
+            .map_err(|_| ShellError::MissingConfigValue("send, edit or until".to_string(), *span))
+    }
+}
+
+fn parse_event(value: &Value, config: &Config) -> Result<ReedlineEvent, ShellError> {
+    match value {
+        Value::Record { cols, vals, span } => {
+            match EventType::try_from_columns(cols, vals, span)? {
+                EventType::Send(value) => event_from_record(
+                    value.into_string("", config).to_lowercase().as_str(),
+                    cols,
+                    vals,
+                    config,
+                    span,
+                ),
+                EventType::Edit(value) => {
+                    let edit = edit_from_record(
+                        value.into_string("", config).to_lowercase().as_str(),
+                        cols,
+                        vals,
+                        config,
+                        span,
+                    )?;
+                    Ok(ReedlineEvent::Edit(vec![edit]))
+                }
+                EventType::Until(value) => match value {
+                    Value::List { vals, .. } => {
+                        let events = vals
+                            .iter()
+                            .map(|value| parse_event(value, config))
+                            .collect::<Result<Vec<ReedlineEvent>, ShellError>>()?;
+
+                        Ok(ReedlineEvent::UntilFound(events))
+                    }
+                    v => Err(ShellError::UnsupportedConfigValue(
+                        "list of events".to_string(),
+                        v.into_abbreviated_string(config),
+                        v.span()?,
+                    )),
+                },
+            }
+        }
+        Value::List { vals, .. } => {
+            let events = vals
+                .iter()
+                .map(|value| parse_event(value, config))
+                .collect::<Result<Vec<ReedlineEvent>, ShellError>>()?;
+
+            Ok(ReedlineEvent::Multiple(events))
+        }
+        v => Err(ShellError::UnsupportedConfigValue(
+            "record or list of records".to_string(),
+            v.into_abbreviated_string(config),
+            v.span()?,
+        )),
+    }
+}
+
+fn event_from_record(
+    name: &str,
+    cols: &[String],
+    vals: &[Value],
+    config: &Config,
+    span: &Span,
+) -> Result<ReedlineEvent, ShellError> {
+    let event = match name {
+        "none" => ReedlineEvent::None,
+        "actionhandler" => ReedlineEvent::ActionHandler,
+        "clearscreen" => ReedlineEvent::ClearScreen,
+        "historyhintcomplete" => ReedlineEvent::HistoryHintComplete,
+        "historyhintwordcomplete" => ReedlineEvent::HistoryHintWordComplete,
+        "ctrld" => ReedlineEvent::CtrlD,
+        "ctrlc" => ReedlineEvent::CtrlC,
+        "enter" => ReedlineEvent::Enter,
+        "esc" | "escape" => ReedlineEvent::Esc,
+        "up" => ReedlineEvent::Up,
+        "down" => ReedlineEvent::Down,
+        "right" => ReedlineEvent::Right,
+        "left" => ReedlineEvent::Left,
+        "searchhistory" => ReedlineEvent::SearchHistory,
+        "nexthistory" => ReedlineEvent::NextHistory,
+        "previoushistory" => ReedlineEvent::PreviousHistory,
+        "repaint" => ReedlineEvent::Repaint,
+        "menudown" => ReedlineEvent::MenuDown,
+        "menuup" => ReedlineEvent::MenuUp,
+        "menuleft" => ReedlineEvent::MenuLeft,
+        "menuright" => ReedlineEvent::MenuRight,
+        "menunext" => ReedlineEvent::MenuNext,
+        "menuprevious" => ReedlineEvent::MenuPrevious,
+        "menupagenext" => ReedlineEvent::MenuPageNext,
+        "menupageprevious" => ReedlineEvent::MenuPagePrevious,
+        "menu" => {
+            let menu = extract_value("name", cols, vals, span)?;
+            ReedlineEvent::Menu(menu.into_string("", config))
+        }
+        "executehostcommand" => {
+            let cmd = extract_value("cmd", cols, vals, span)?;
+            ReedlineEvent::ExecuteHostCommand(cmd.into_string("", config))
+        }
+        v => {
+            return Err(ShellError::UnsupportedConfigValue(
+                "Reedline event".to_string(),
+                v.to_string(),
+                *span,
+            ))
+        }
+    };
+
+    Ok(event)
+}
+
+fn edit_from_record(
+    name: &str,
+    cols: &[String],
+    vals: &[Value],
+    config: &Config,
+    span: &Span,
+) -> Result<EditCommand, ShellError> {
+    let edit = match name {
+        "movetostart" => EditCommand::MoveToStart,
+        "movetolinestart" => EditCommand::MoveToLineStart,
+        "movetoend" => EditCommand::MoveToEnd,
+        "movetolineend" => EditCommand::MoveToLineEnd,
+        "moveleft" => EditCommand::MoveLeft,
+        "moveright" => EditCommand::MoveRight,
+        "movewordleft" => EditCommand::MoveWordLeft,
+        "movewordright" => EditCommand::MoveWordRight,
+        "insertchar" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::InsertChar(char)
+        }
+        "insertstring" => {
+            let value = extract_value("value", cols, vals, span)?;
+            EditCommand::InsertString(value.into_string("", config))
+        }
+        "backspace" => EditCommand::Backspace,
+        "delete" => EditCommand::Delete,
+        "backspaceword" => EditCommand::BackspaceWord,
+        "deleteword" => EditCommand::DeleteWord,
+        "clear" => EditCommand::Clear,
+        "cleartolineend" => EditCommand::ClearToLineEnd,
+        "cutcurrentline" => EditCommand::CutCurrentLine,
+        "cutfromstart" => EditCommand::CutFromStart,
+        "cutfromlinestart" => EditCommand::CutFromLineStart,
+        "cuttoend" => EditCommand::CutToEnd,
+        "cuttolineend" => EditCommand::CutToLineEnd,
+        "cutwordleft" => EditCommand::CutWordLeft,
+        "cutwordright" => EditCommand::CutWordRight,
+        "pastecutbufferbefore" => EditCommand::PasteCutBufferBefore,
+        "pastecutbufferafter" => EditCommand::PasteCutBufferAfter,
+        "uppercaseword" => EditCommand::UppercaseWord,
+        "lowercaseword" => EditCommand::LowercaseWord,
+        "capitalizechar" => EditCommand::CapitalizeChar,
+        "swapwords" => EditCommand::SwapWords,
+        "swapgraphemes" => EditCommand::SwapGraphemes,
+        "undo" => EditCommand::Undo,
+        "redo" => EditCommand::Redo,
+        "cutrightuntil" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::CutRightUntil(char)
+        }
+        "cutrightbefore" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::CutRightBefore(char)
+        }
+        "moverightuntil" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::MoveRightUntil(char)
+        }
+        "moverightbefore" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::MoveRightBefore(char)
+        }
+        "cutleftuntil" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::CutLeftUntil(char)
+        }
+        "cutleftbefore" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::CutLeftBefore(char)
+        }
+        "moveleftuntil" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::MoveLeftUntil(char)
+        }
+        "moveleftbefore" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::MoveLeftBefore(char)
+        }
+        e => {
+            return Err(ShellError::UnsupportedConfigValue(
+                "reedline EditCommand".to_string(),
+                e.to_string(),
+                *span,
+            ))
+        }
+    };
+
+    Ok(edit)
+}
+
+fn extract_char(value: &Value, config: &Config) -> Result<char, ShellError> {
+    let span = value.span()?;
+    value
+        .into_string("", config)
+        .chars()
+        .next()
+        .ok_or_else(|| ShellError::MissingConfigValue("char to insert".to_string(), span))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_send_event() {
+        let cols = vec!["send".to_string()];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
+
+        let span = Span::test_data();
+        let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
+        assert!(matches!(b, EventType::Send(_)));
+
+        let event = Value::Record {
+            vals,
+            cols,
+            span: Span::test_data(),
+        };
+        let config = Config::default();
+
+        let parsed_event = parse_event(&event, &config).unwrap();
+        assert_eq!(parsed_event, ReedlineEvent::Enter);
+    }
+
+    #[test]
+    fn test_edit_event() {
+        let cols = vec!["edit".to_string()];
+        let vals = vec![Value::String {
+            val: "Clear".to_string(),
+            span: Span::test_data(),
+        }];
+
+        let span = Span::test_data();
+        let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
+        assert!(matches!(b, EventType::Edit(_)));
+
+        let event = Value::Record {
+            vals,
+            cols,
+            span: Span::test_data(),
+        };
+        let config = Config::default();
+
+        let parsed_event = parse_event(&event, &config).unwrap();
+        assert_eq!(parsed_event, ReedlineEvent::Edit(vec![EditCommand::Clear]));
+    }
+
+    #[test]
+    fn test_send_menu() {
+        let cols = vec!["send".to_string(), "name".to_string()];
+        let vals = vec![
+            Value::String {
+                val: "Menu".to_string(),
+                span: Span::test_data(),
+            },
+            Value::String {
+                val: "history_menu".to_string(),
+                span: Span::test_data(),
+            },
+        ];
+
+        let span = Span::test_data();
+        let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
+        assert!(matches!(b, EventType::Send(_)));
+
+        let event = Value::Record {
+            vals,
+            cols,
+            span: Span::test_data(),
+        };
+        let config = Config::default();
+
+        let parsed_event = parse_event(&event, &config).unwrap();
+        assert_eq!(
+            parsed_event,
+            ReedlineEvent::Menu("history_menu".to_string())
+        );
+    }
+
+    #[test]
+    fn test_until_event() {
+        // Menu event
+        let cols = vec!["send".to_string(), "name".to_string()];
+        let vals = vec![
+            Value::String {
+                val: "Menu".to_string(),
+                span: Span::test_data(),
+            },
+            Value::String {
+                val: "history_menu".to_string(),
+                span: Span::test_data(),
+            },
+        ];
+
+        let menu_event = Value::Record {
+            cols,
+            vals,
+            span: Span::test_data(),
+        };
+
+        // Enter event
+        let cols = vec!["send".to_string()];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
+
+        let enter_event = Value::Record {
+            cols,
+            vals,
+            span: Span::test_data(),
+        };
+
+        // Until event
+        let cols = vec!["until".to_string()];
+        let vals = vec![Value::List {
+            vals: vec![menu_event, enter_event],
+            span: Span::test_data(),
+        }];
+
+        let span = Span::test_data();
+        let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
+        assert!(matches!(b, EventType::Until(_)));
+
+        let event = Value::Record {
+            cols,
+            vals,
+            span: Span::test_data(),
+        };
+        let config = Config::default();
+
+        let parsed_event = parse_event(&event, &config).unwrap();
+        assert_eq!(
+            parsed_event,
+            ReedlineEvent::UntilFound(vec![
+                ReedlineEvent::Menu("history_menu".to_string()),
+                ReedlineEvent::Enter,
+            ])
+        );
+    }
+
+    #[test]
+    fn test_multiple_event() {
+        // Menu event
+        let cols = vec!["send".to_string(), "name".to_string()];
+        let vals = vec![
+            Value::String {
+                val: "Menu".to_string(),
+                span: Span::test_data(),
+            },
+            Value::String {
+                val: "history_menu".to_string(),
+                span: Span::test_data(),
+            },
+        ];
+
+        let menu_event = Value::Record {
+            cols,
+            vals,
+            span: Span::test_data(),
+        };
+
+        // Enter event
+        let cols = vec!["send".to_string()];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
+
+        let enter_event = Value::Record {
+            cols,
+            vals,
+            span: Span::test_data(),
+        };
+
+        // Multiple event
+        let event = Value::List {
+            vals: vec![menu_event, enter_event],
+            span: Span::test_data(),
+        };
+
+        let config = Config::default();
+        let parsed_event = parse_event(&event, &config).unwrap();
+        assert_eq!(
+            parsed_event,
+            ReedlineEvent::Multiple(vec![
+                ReedlineEvent::Menu("history_menu".to_string()),
+                ReedlineEvent::Enter,
+            ])
+        );
+    }
+
+    #[test]
+    fn test_error() {
+        let cols = vec!["not_exist".to_string()];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
+
+        let span = Span::test_data();
+        let b = EventType::try_from_columns(&cols, &vals, &span);
+        assert!(matches!(b, Err(ShellError::MissingConfigValue(_, _))));
+    }
+}

crates/nu-cli/src/repl.rs

@@ -0,0 +1,367 @@
+use crate::reedline_config::{add_completion_menu, add_history_menu};
+use crate::{prompt_update, reedline_config};
+use crate::{
+    reedline_config::KeybindingsMode,
+    util::{eval_source, report_error},
+};
+use crate::{NuCompleter, NuHighlighter, NuValidator, NushellPrompt};
+use log::info;
+use log::trace;
+use miette::{IntoDiagnostic, Result};
+use nu_color_config::get_color_config;
+use nu_engine::convert_env_values;
+use nu_parser::lex;
+use nu_protocol::engine::Stack;
+use nu_protocol::PipelineData;
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    Config, ShellError, Span, Value, CONFIG_VARIABLE_ID,
+};
+use reedline::{DefaultHinter, Emacs, Vi};
+use std::path::PathBuf;
+use std::{sync::atomic::Ordering, time::Instant};
+
+pub fn evaluate_repl(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    history_path: Option<PathBuf>,
+    is_perf_true: bool,
+) -> Result<()> {
+    // use crate::logger::{configure, logger};
+    use reedline::{FileBackedHistory, Reedline, Signal};
+
+    let mut entry_num = 0;
+
+    let mut nu_prompt = NushellPrompt::new();
+    // let mut stack = nu_protocol::engine::Stack::new();
+
+    // First, set up env vars as strings only
+    // gather_parent_env_vars(engine_state);
+
+    // Set up our initial config to start from
+    // stack.vars.insert(
+    //     CONFIG_VARIABLE_ID,
+    //     Value::Record {
+    //         cols: vec![],
+    //         vals: vec![],
+    //         span: Span::new(0, 0),
+    //     },
+    // );
+
+    if is_perf_true {
+        info!("read_plugin_file {}:{}:{}", file!(), line!(), column!());
+    }
+
+    // #[cfg(feature = "plugin")]
+    // config_files::read_plugin_file(engine_state, &mut stack, is_perf_true);
+    //
+    // if is_perf_true {
+    //     info!("read_config_file {}:{}:{}", file!(), line!(), column!());
+    // }
+    //
+    // config_files::read_config_file(engine_state, &mut stack, config_file, is_perf_true);
+    // let history_path = config_files::create_history_path();
+
+    // logger(|builder| {
+    //     configure(&config.log_level, builder)?;
+    //     // trace_filters(self, builder)?;
+    //     // debug_filters(self, builder)?;
+
+    //     Ok(())
+    // })?;
+
+    if is_perf_true {
+        info!(
+            "translate environment vars {}:{}:{}",
+            file!(),
+            line!(),
+            column!()
+        );
+    }
+
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+    }
+
+    // Make a note of the exceptions we see for externals that look like math expressions
+    let exceptions = crate::util::external_exceptions(engine_state, stack);
+    engine_state.external_exceptions = exceptions;
+
+    // seed env vars
+    stack.add_env_var(
+        "CMD_DURATION_MS".into(),
+        Value::String {
+            val: "0823".to_string(),
+            span: Span { start: 0, end: 0 },
+        },
+    );
+
+    stack.add_env_var(
+        "LAST_EXIT_CODE".into(),
+        Value::Int {
+            val: 0,
+            span: Span { start: 0, end: 0 },
+        },
+    );
+
+    loop {
+        if is_perf_true {
+            info!(
+                "load config each loop {}:{}:{}",
+                file!(),
+                line!(),
+                column!()
+            );
+        }
+
+        let config = match stack.get_config() {
+            Ok(config) => config,
+            Err(e) => {
+                let working_set = StateWorkingSet::new(engine_state);
+
+                report_error(&working_set, &e);
+                Config::default()
+            }
+        };
+
+        //Reset the ctrl-c handler
+        if let Some(ctrlc) = &mut engine_state.ctrlc {
+            ctrlc.store(false, Ordering::SeqCst);
+        }
+
+        if is_perf_true {
+            info!("setup line editor {}:{}:{}", file!(), line!(), column!());
+        }
+
+        let mut line_editor = Reedline::create()
+            .into_diagnostic()?
+            .with_highlighter(Box::new(NuHighlighter {
+                engine_state: engine_state.clone(),
+                config: config.clone(),
+            }))
+            .with_animation(config.animate_prompt)
+            .with_validator(Box::new(NuValidator {
+                engine_state: engine_state.clone(),
+            }))
+            .with_completer(Box::new(NuCompleter::new(
+                engine_state.clone(),
+                stack.vars.get(&CONFIG_VARIABLE_ID).cloned(),
+            )))
+            .with_quick_completions(config.quick_completions)
+            .with_partial_completions(config.partial_completions)
+            .with_ansi_colors(config.use_ansi_coloring);
+
+        if is_perf_true {
+            info!("setup reedline {}:{}:{}", file!(), line!(), column!());
+        }
+
+        line_editor = add_completion_menu(line_editor, &config);
+        line_editor = add_history_menu(line_editor, &config);
+
+        if is_perf_true {
+            info!("setup colors {}:{}:{}", file!(), line!(), column!());
+        }
+        //FIXME: if config.use_ansi_coloring is false then we should
+        // turn off the hinter but I don't see any way to do that yet.
+
+        let color_hm = get_color_config(&config);
+
+        if is_perf_true {
+            info!(
+                "setup history and hinter {}:{}:{}",
+                file!(),
+                line!(),
+                column!()
+            );
+        }
+
+        line_editor = if let Some(history_path) = history_path.clone() {
+            let history = std::fs::read_to_string(&history_path);
+            if history.is_ok() {
+                line_editor
+                    .with_hinter(Box::new(
+                        DefaultHinter::default().with_style(color_hm["hints"]),
+                    ))
+                    .with_history(Box::new(
+                        FileBackedHistory::with_file(
+                            config.max_history_size as usize,
+                            history_path.clone(),
+                        )
+                        .into_diagnostic()?,
+                    ))
+                    .into_diagnostic()?
+            } else {
+                line_editor
+            }
+        } else {
+            line_editor
+        };
+
+        if is_perf_true {
+            info!("setup keybindings {}:{}:{}", file!(), line!(), column!());
+        }
+
+        // Changing the line editor based on the found keybindings
+        line_editor = match reedline_config::create_keybindings(&config) {
+            Ok(keybindings) => match keybindings {
+                KeybindingsMode::Emacs(keybindings) => {
+                    let edit_mode = Box::new(Emacs::new(keybindings));
+                    line_editor.with_edit_mode(edit_mode)
+                }
+                KeybindingsMode::Vi {
+                    insert_keybindings,
+                    normal_keybindings,
+                } => {
+                    let edit_mode = Box::new(Vi::new(insert_keybindings, normal_keybindings));
+                    line_editor.with_edit_mode(edit_mode)
+                }
+            },
+            Err(e) => {
+                let working_set = StateWorkingSet::new(engine_state);
+                report_error(&working_set, &e);
+                line_editor
+            }
+        };
+
+        if is_perf_true {
+            info!("prompt_update {}:{}:{}", file!(), line!(), column!());
+        }
+
+        let prompt = prompt_update::update_prompt(
+            &config,
+            engine_state,
+            stack,
+            &mut nu_prompt,
+            is_perf_true,
+        );
+
+        entry_num += 1;
+
+        if is_perf_true {
+            info!(
+                "finished setup, starting repl {}:{}:{}",
+                file!(),
+                line!(),
+                column!()
+            );
+        }
+
+        let input = line_editor.read_line(prompt);
+        match input {
+            Ok(Signal::Success(s)) => {
+                let start_time = Instant::now();
+                let tokens = lex(s.as_bytes(), 0, &[], &[], false);
+                // Check if this is a single call to a directory, if so auto-cd
+                let cwd = nu_engine::env::current_dir_str(engine_state, stack)?;
+                let path = nu_path::expand_path_with(&s, &cwd);
+
+                let orig = s.clone();
+
+                if (orig.starts_with('.')
+                    || orig.starts_with('~')
+                    || orig.starts_with('/')
+                    || orig.starts_with('\\'))
+                    && path.is_dir()
+                    && tokens.0.len() == 1
+                {
+                    // We have an auto-cd
+                    let (path, span) = {
+                        if !path.exists() {
+                            let working_set = StateWorkingSet::new(engine_state);
+
+                            report_error(
+                                &working_set,
+                                &ShellError::DirectoryNotFound(tokens.0[0].span),
+                            );
+                        }
+
+                        let path = nu_path::canonicalize_with(path, &cwd)
+                            .expect("internal error: cannot canonicalize known path");
+                        (path.to_string_lossy().to_string(), tokens.0[0].span)
+                    };
+
+                    //FIXME: this only changes the current scope, but instead this environment variable
+                    //should probably be a block that loads the information from the state in the overlay
+                    stack.add_env_var(
+                        "PWD".into(),
+                        Value::String {
+                            val: path.clone(),
+                            span: Span { start: 0, end: 0 },
+                        },
+                    );
+                    let cwd = Value::String { val: cwd, span };
+
+                    let shells = stack.get_env_var(engine_state, "NUSHELL_SHELLS");
+                    let mut shells = if let Some(v) = shells {
+                        v.as_list()
+                            .map(|x| x.to_vec())
+                            .unwrap_or_else(|_| vec![cwd])
+                    } else {
+                        vec![cwd]
+                    };
+
+                    let current_shell = stack.get_env_var(engine_state, "NUSHELL_CURRENT_SHELL");
+                    let current_shell = if let Some(v) = current_shell {
+                        v.as_integer().unwrap_or_default() as usize
+                    } else {
+                        0
+                    };
+
+                    shells[current_shell] = Value::String { val: path, span };
+
+                    stack.add_env_var("NUSHELL_SHELLS".into(), Value::List { vals: shells, span });
+                } else {
+                    trace!("eval source: {}", s);
+
+                    eval_source(
+                        engine_state,
+                        stack,
+                        s.as_bytes(),
+                        &format!("entry #{}", entry_num),
+                        PipelineData::new(Span::new(0, 0)),
+                    );
+
+                    stack.add_env_var(
+                        "CMD_DURATION_MS".into(),
+                        Value::String {
+                            val: format!("{}", start_time.elapsed().as_millis()),
+                            span: Span { start: 0, end: 0 },
+                        },
+                    );
+                }
+                // FIXME: permanent state changes like this hopefully in time can be removed
+                // and be replaced by just passing the cwd in where needed
+                if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
+                    let path = cwd.as_string()?;
+                    let _ = std::env::set_current_dir(path);
+                    engine_state.env_vars.insert("PWD".into(), cwd);
+                }
+
+                // Make a note of the exceptions we see for externals that look like math expressions
+                let exceptions = crate::util::external_exceptions(engine_state, stack);
+                engine_state.external_exceptions = exceptions;
+            }
+            Ok(Signal::CtrlC) => {
+                // `Reedline` clears the line content. New prompt is shown
+            }
+            Ok(Signal::CtrlD) => {
+                // When exiting clear to a new line
+                println!();
+                break;
+            }
+            Ok(Signal::CtrlL) => {
+                line_editor.clear_screen().into_diagnostic()?;
+            }
+            Err(err) => {
+                let message = err.to_string();
+                if !message.contains("duration") {
+                    println!("Error: {:?}", err);
+                }
+            }
+        }
+    }
+
+    Ok(())
+}

crates/nu-cli/src/syntax_highlight.rs

@@ -0,0 +1,213 @@
+use log::trace;
+use nu_ansi_term::Style;
+use nu_color_config::get_shape_color;
+use nu_parser::{flatten_block, parse, FlatShape};
+use nu_protocol::engine::{EngineState, StateWorkingSet};
+use nu_protocol::Config;
+use reedline::{Highlighter, StyledText};
+
+pub struct NuHighlighter {
+    pub engine_state: EngineState,
+    pub config: Config,
+}
+
+impl Highlighter for NuHighlighter {
+    fn highlight(&self, line: &str, _cursor: usize) -> StyledText {
+        trace!("highlighting: {}", line);
+
+        let (shapes, global_span_offset) = {
+            let mut working_set = StateWorkingSet::new(&self.engine_state);
+            let (block, _) = parse(&mut working_set, None, line.as_bytes(), false, &[]);
+
+            let shapes = flatten_block(&working_set, &block);
+            (shapes, self.engine_state.next_span_start())
+        };
+
+        let mut output = StyledText::default();
+        let mut last_seen_span = global_span_offset;
+
+        for shape in &shapes {
+            if shape.0.end <= last_seen_span
+                || last_seen_span < global_span_offset
+                || shape.0.start < global_span_offset
+            {
+                // We've already output something for this span
+                // so just skip this one
+                continue;
+            }
+            if shape.0.start > last_seen_span {
+                let gap = line
+                    [(last_seen_span - global_span_offset)..(shape.0.start - global_span_offset)]
+                    .to_string();
+                output.push((Style::new(), gap));
+            }
+            let next_token = line
+                [(shape.0.start - global_span_offset)..(shape.0.end - global_span_offset)]
+                .to_string();
+            match shape.1 {
+                FlatShape::Garbage => output.push((
+                    // nushell Garbage
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Nothing => output.push((
+                    // nushell Nothing
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Binary => {
+                    // nushell ?
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Bool => {
+                    // nushell ?
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Int => {
+                    // nushell Int
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Float => {
+                    // nushell Decimal
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Range => output.push((
+                    // nushell DotDot ?
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::InternalCall => output.push((
+                    // nushell InternalCommand
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::External => {
+                    // nushell ExternalCommand
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::ExternalArg => {
+                    // nushell ExternalWord
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Literal => {
+                    // nushell ?
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Operator => output.push((
+                    // nushell Operator
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Signature => output.push((
+                    // nushell ?
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::String => {
+                    // nushell String
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::StringInterpolation => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::DateTime => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::List => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Table => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Record => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Block => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Filepath => output.push((
+                    // nushell Path
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::GlobPattern => output.push((
+                    // nushell GlobPattern
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Variable => output.push((
+                    // nushell Variable
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Flag => {
+                    // nushell Flag
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Custom(..) => output.push((
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+            }
+            last_seen_span = shape.0.end;
+        }
+
+        let remainder = line[(last_seen_span - global_span_offset)..].to_string();
+        if !remainder.is_empty() {
+            output.push((Style::new(), remainder));
+        }
+
+        output
+    }
+}

crates/nu-cli/src/util.rs

@@ -0,0 +1,487 @@
+use crate::CliError;
+use log::trace;
+use nu_engine::eval_block;
+use nu_parser::{lex, parse, trim_quotes, Token, TokenContents};
+use nu_protocol::engine::StateWorkingSet;
+use nu_protocol::{
+    ast::Call,
+    engine::{EngineState, Stack},
+    PipelineData, ShellError, Span, Value,
+};
+#[cfg(windows)]
+use nu_utils::enable_vt_processing;
+use std::io::Write;
+use std::path::PathBuf;
+
+pub fn print_pipeline_data(
+    input: PipelineData,
+    engine_state: &EngineState,
+    stack: &mut Stack,
+) -> Result<(), ShellError> {
+    // If the table function is in the declarations, then we can use it
+    // to create the table value that will be printed in the terminal
+
+    let config = stack.get_config().unwrap_or_default();
+
+    let stdout = std::io::stdout();
+
+    if let PipelineData::ExternalStream {
+        stdout: stream,
+        exit_code,
+        ..
+    } = input
+    {
+        if let Some(stream) = stream {
+            for s in stream {
+                let _ = stdout.lock().write_all(s?.as_binary()?);
+            }
+        }
+
+        // Make sure everything has finished
+        if let Some(exit_code) = exit_code {
+            let _: Vec<_> = exit_code.into_iter().collect();
+        }
+
+        return Ok(());
+    }
+
+    match engine_state.find_decl("table".as_bytes()) {
+        Some(decl_id) => {
+            let table = engine_state.get_decl(decl_id).run(
+                engine_state,
+                stack,
+                &Call::new(Span::new(0, 0)),
+                input,
+            )?;
+
+            for item in table {
+                let stdout = std::io::stdout();
+
+                if let Value::Error { error } = item {
+                    return Err(error);
+                }
+
+                let mut out = item.into_string("\n", &config);
+                out.push('\n');
+
+                match stdout.lock().write_all(out.as_bytes()) {
+                    Ok(_) => (),
+                    Err(err) => eprintln!("{}", err),
+                };
+            }
+        }
+        None => {
+            for item in input {
+                let stdout = std::io::stdout();
+
+                if let Value::Error { error } = item {
+                    return Err(error);
+                }
+
+                let mut out = item.into_string("\n", &config);
+                out.push('\n');
+
+                match stdout.lock().write_all(out.as_bytes()) {
+                    Ok(_) => (),
+                    Err(err) => eprintln!("{}", err),
+                };
+            }
+        }
+    };
+
+    Ok(())
+}
+
+// This will collect environment variables from std::env and adds them to a stack.
+//
+// In order to ensure the values have spans, it first creates a dummy file, writes the collected
+// env vars into it (in a "NAME"="value" format, quite similar to the output of the Unix 'env'
+// tool), then uses the file to get the spans. The file stays in memory, no filesystem IO is done.
+pub fn gather_parent_env_vars(engine_state: &mut EngineState) {
+    // Some helper functions
+    fn get_surround_char(s: &str) -> Option<char> {
+        if s.contains('"') {
+            if s.contains('\'') {
+                None
+            } else {
+                Some('\'')
+            }
+        } else {
+            Some('\'')
+        }
+    }
+
+    fn report_capture_error(engine_state: &EngineState, env_str: &str, msg: &str) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(
+            &working_set,
+            &ShellError::LabeledError(
+                format!("Environment variable was not captured: {}", env_str),
+                msg.into(),
+            ),
+        );
+    }
+
+    fn put_env_to_fake_file(
+        name: &str,
+        val: &str,
+        fake_env_file: &mut String,
+        engine_state: &EngineState,
+    ) {
+        let (c_name, c_val) =
+            if let (Some(cn), Some(cv)) = (get_surround_char(name), get_surround_char(val)) {
+                (cn, cv)
+            } else {
+                // environment variable with its name or value containing both ' and " is ignored
+                report_capture_error(
+                    engine_state,
+                    &format!("{}={}", name, val),
+                    "Name or value should not contain both ' and \" at the same time.",
+                );
+                return;
+            };
+
+        fake_env_file.push(c_name);
+        fake_env_file.push_str(name);
+        fake_env_file.push(c_name);
+        fake_env_file.push('=');
+        fake_env_file.push(c_val);
+        fake_env_file.push_str(val);
+        fake_env_file.push(c_val);
+        fake_env_file.push('\n');
+    }
+
+    let mut fake_env_file = String::new();
+
+    // Make sure we always have PWD
+    if std::env::var("PWD").is_err() {
+        match std::env::current_dir() {
+            Ok(cwd) => {
+                put_env_to_fake_file(
+                    "PWD",
+                    &cwd.to_string_lossy(),
+                    &mut fake_env_file,
+                    engine_state,
+                );
+            }
+            Err(e) => {
+                // Could not capture current working directory
+                let working_set = StateWorkingSet::new(engine_state);
+                report_error(
+                    &working_set,
+                    &ShellError::LabeledError(
+                        "Current directory not found".to_string(),
+                        format!("Retrieving current directory failed: {:?}", e),
+                    ),
+                );
+            }
+        }
+    }
+
+    // Write all the env vars into a fake file
+    for (name, val) in std::env::vars() {
+        put_env_to_fake_file(&name, &val, &mut fake_env_file, engine_state);
+    }
+
+    // Lex the fake file, assign spans to all environment variables and add them
+    // to stack
+    let span_offset = engine_state.next_span_start();
+
+    engine_state.add_file(
+        "Host Environment Variables".to_string(),
+        fake_env_file.as_bytes().to_vec(),
+    );
+
+    let (tokens, _) = lex(fake_env_file.as_bytes(), span_offset, &[], &[], true);
+
+    for token in tokens {
+        if let Token {
+            contents: TokenContents::Item,
+            span: full_span,
+        } = token
+        {
+            let contents = engine_state.get_span_contents(&full_span);
+            let (parts, _) = lex(contents, full_span.start, &[], &[b'='], true);
+
+            let name = if let Some(Token {
+                contents: TokenContents::Item,
+                span,
+            }) = parts.get(0)
+            {
+                let bytes = engine_state.get_span_contents(span);
+
+                if bytes.len() < 2 {
+                    report_capture_error(
+                        engine_state,
+                        &String::from_utf8_lossy(contents),
+                        "Got empty name.",
+                    );
+
+                    continue;
+                }
+
+                let bytes = trim_quotes(bytes);
+                String::from_utf8_lossy(bytes).to_string()
+            } else {
+                report_capture_error(
+                    engine_state,
+                    &String::from_utf8_lossy(contents),
+                    "Got empty name.",
+                );
+
+                continue;
+            };
+
+            let value = if let Some(Token {
+                contents: TokenContents::Item,
+                span,
+            }) = parts.get(2)
+            {
+                let bytes = engine_state.get_span_contents(span);
+
+                if bytes.len() < 2 {
+                    report_capture_error(
+                        engine_state,
+                        &String::from_utf8_lossy(contents),
+                        "Got empty value.",
+                    );
+
+                    continue;
+                }
+
+                let bytes = trim_quotes(bytes);
+
+                Value::String {
+                    val: String::from_utf8_lossy(bytes).to_string(),
+                    span: *span,
+                }
+            } else {
+                report_capture_error(
+                    engine_state,
+                    &String::from_utf8_lossy(contents),
+                    "Got empty value.",
+                );
+
+                continue;
+            };
+
+            // stack.add_env_var(name, value);
+            engine_state.env_vars.insert(name, value);
+        }
+    }
+}
+
+pub fn eval_source(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    source: &[u8],
+    fname: &str,
+    input: PipelineData,
+) -> bool {
+    trace!("eval_source");
+
+    let (block, delta) = {
+        let mut working_set = StateWorkingSet::new(engine_state);
+        let (output, err) = parse(
+            &mut working_set,
+            Some(fname), // format!("entry #{}", entry_num)
+            source,
+            false,
+            &[],
+        );
+        if let Some(err) = err {
+            report_error(&working_set, &err);
+            return false;
+        }
+
+        (output, working_set.render())
+    };
+
+    let cwd = match nu_engine::env::current_dir_str(engine_state, stack) {
+        Ok(p) => PathBuf::from(p),
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
+            get_init_cwd()
+        }
+    };
+
+    if let Err(err) = engine_state.merge_delta(delta, Some(stack), &cwd) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &err);
+    }
+
+    match eval_block(engine_state, stack, &block, input, false, false) {
+        Ok(mut pipeline_data) => {
+            if let PipelineData::ExternalStream { exit_code, .. } = &mut pipeline_data {
+                if let Some(exit_code) = exit_code.take().and_then(|it| it.last()) {
+                    stack.add_env_var("LAST_EXIT_CODE".to_string(), exit_code);
+                } else {
+                    stack.add_env_var(
+                        "LAST_EXIT_CODE".to_string(),
+                        Value::Int {
+                            val: 0,
+                            span: Span { start: 0, end: 0 },
+                        },
+                    );
+                }
+            } else {
+                stack.add_env_var(
+                    "LAST_EXIT_CODE".to_string(),
+                    Value::Int {
+                        val: 0,
+                        span: Span { start: 0, end: 0 },
+                    },
+                );
+            }
+
+            if let Err(err) = print_pipeline_data(pipeline_data, engine_state, stack) {
+                let working_set = StateWorkingSet::new(engine_state);
+
+                report_error(&working_set, &err);
+
+                return false;
+            }
+
+            // reset vt processing, aka ansi because illbehaved externals can break it
+            #[cfg(windows)]
+            {
+                let _ = enable_vt_processing();
+            }
+        }
+        Err(err) => {
+            stack.add_env_var(
+                "LAST_EXIT_CODE".to_string(),
+                Value::Int {
+                    val: 1,
+                    span: Span { start: 0, end: 0 },
+                },
+            );
+
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &err);
+
+            return false;
+        }
+    }
+
+    true
+}
+
+fn seems_like_number(bytes: &[u8]) -> bool {
+    if bytes.is_empty() {
+        false
+    } else {
+        let b = bytes[0];
+
+        b == b'0'
+            || b == b'1'
+            || b == b'2'
+            || b == b'3'
+            || b == b'4'
+            || b == b'5'
+            || b == b'6'
+            || b == b'7'
+            || b == b'8'
+            || b == b'9'
+            || b == b'('
+            || b == b'{'
+            || b == b'['
+            || b == b'$'
+            || b == b'"'
+            || b == b'\''
+            || b == b'-'
+    }
+}
+
+/// Finds externals that have names that look like math expressions
+pub fn external_exceptions(engine_state: &EngineState, stack: &Stack) -> Vec<Vec<u8>> {
+    let mut executables = vec![];
+
+    if let Some(path) = stack.get_env_var(engine_state, "PATH") {
+        match path {
+            Value::List { vals, .. } => {
+                for val in vals {
+                    let path = val.as_string();
+
+                    if let Ok(path) = path {
+                        if let Ok(mut contents) = std::fs::read_dir(path) {
+                            while let Some(Ok(item)) = contents.next() {
+                                if is_executable::is_executable(&item.path()) {
+                                    if let Ok(name) = item.file_name().into_string() {
+                                        if seems_like_number(name.as_bytes()) {
+                                            let name = name.as_bytes().to_vec();
+                                            executables.push(name);
+                                        }
+                                    }
+
+                                    if let Some(name) = item.path().file_stem() {
+                                        let name = name.to_string_lossy();
+                                        if seems_like_number(name.as_bytes()) {
+                                            let name = name.as_bytes().to_vec();
+                                            executables.push(name);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            Value::String { val, .. } => {
+                for path in std::env::split_paths(&val) {
+                    let path = path.to_string_lossy().to_string();
+
+                    if let Ok(mut contents) = std::fs::read_dir(path) {
+                        while let Some(Ok(item)) = contents.next() {
+                            if is_executable::is_executable(&item.path()) {
+                                if let Ok(name) = item.file_name().into_string() {
+                                    if seems_like_number(name.as_bytes()) {
+                                        let name = name.as_bytes().to_vec();
+                                        executables.push(name);
+                                    }
+                                }
+                                if let Some(name) = item.path().file_stem() {
+                                    let name = name.to_string_lossy();
+                                    if seems_like_number(name.as_bytes()) {
+                                        let name = name.as_bytes().to_vec();
+                                        executables.push(name);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    executables
+}
+
+pub fn report_error(
+    working_set: &StateWorkingSet,
+    error: &(dyn miette::Diagnostic + Send + Sync + 'static),
+) {
+    eprintln!("Error: {:?}", CliError(error, working_set));
+    // reset vt processing, aka ansi because illbehaved externals can break it
+    #[cfg(windows)]
+    {
+        let _ = nu_utils::enable_vt_processing();
+    }
+}
+
+pub fn get_init_cwd() -> PathBuf {
+    match std::env::current_dir() {
+        Ok(cwd) => cwd,
+        Err(_) => match std::env::var("PWD") {
+            Ok(cwd) => PathBuf::from(cwd),
+            Err(_) => match nu_path::home_dir() {
+                Some(cwd) => cwd,
+                None => PathBuf::new(),
+            },
+        },
+    }
+}

crates/nu-cli/src/validation.rs

@@ -0,0 +1,20 @@
+use nu_parser::{parse, ParseError};
+use nu_protocol::engine::{EngineState, StateWorkingSet};
+use reedline::{ValidationResult, Validator};
+
+pub struct NuValidator {
+    pub engine_state: EngineState,
+}
+
+impl Validator for NuValidator {
+    fn validate(&self, line: &str) -> ValidationResult {
+        let mut working_set = StateWorkingSet::new(&self.engine_state);
+        let (_, err) = parse(&mut working_set, None, line.as_bytes(), false, &[]);
+
+        if matches!(err, Some(ParseError::UnexpectedEof(..))) {
+            ValidationResult::Incomplete
+        } else {
+            ValidationResult::Complete
+        }
+    }
+}

crates/nu-color-config/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "nu-color-config"
+version = "0.60.0"
+edition = "2021"
+
+[dependencies]
+nu-protocol = { path = "../nu-protocol", version = "0.60.0"  }
+nu-ansi-term = "0.45.0"
+
+nu-json = { path = "../nu-json", version = "0.60.0"  }
+nu-table = { path = "../nu-table", version = "0.60.0"  }
+
+serde = { version="1.0.123", features=["derive"] }

crates/nu-color-config/src/color_config.rs

@@ -0,0 +1,411 @@
+use crate::nu_style::{color_from_hex, color_string_to_nustyle};
+use nu_ansi_term::{Color, Style};
+use nu_protocol::Config;
+use nu_table::{Alignment, TextStyle};
+use std::collections::HashMap;
+
+pub fn lookup_ansi_color_style(s: &str) -> Style {
+    if s.starts_with('#') {
+        match color_from_hex(s) {
+            Ok(c) => match c {
+                Some(c) => c.normal(),
+                None => Style::default(),
+            },
+            Err(_) => Style::default(),
+        }
+    } else if s.starts_with('{') {
+        color_string_to_nustyle(s.to_string())
+    } else {
+        match s {
+            "g" | "green" => Color::Green.normal(),
+            "gb" | "green_bold" => Color::Green.bold(),
+            "gu" | "green_underline" => Color::Green.underline(),
+            "gi" | "green_italic" => Color::Green.italic(),
+            "gd" | "green_dimmed" => Color::Green.dimmed(),
+            "gr" | "green_reverse" => Color::Green.reverse(),
+            "gbl" | "green_blink" => Color::Green.blink(),
+            "gst" | "green_strike" => Color::Green.strikethrough(),
+
+            "lg" | "light_green" => Color::LightGreen.normal(),
+            "lgb" | "light_green_bold" => Color::LightGreen.bold(),
+            "lgu" | "light_green_underline" => Color::LightGreen.underline(),
+            "lgi" | "light_green_italic" => Color::LightGreen.italic(),
+            "lgd" | "light_green_dimmed" => Color::LightGreen.dimmed(),
+            "lgr" | "light_green_reverse" => Color::LightGreen.reverse(),
+            "lgbl" | "light_green_blink" => Color::LightGreen.blink(),
+            "lgst" | "light_green_strike" => Color::LightGreen.strikethrough(),
+
+            "r" | "red" => Color::Red.normal(),
+            "rb" | "red_bold" => Color::Red.bold(),
+            "ru" | "red_underline" => Color::Red.underline(),
+            "ri" | "red_italic" => Color::Red.italic(),
+            "rd" | "red_dimmed" => Color::Red.dimmed(),
+            "rr" | "red_reverse" => Color::Red.reverse(),
+            "rbl" | "red_blink" => Color::Red.blink(),
+            "rst" | "red_strike" => Color::Red.strikethrough(),
+
+            "lr" | "light_red" => Color::LightRed.normal(),
+            "lrb" | "light_red_bold" => Color::LightRed.bold(),
+            "lru" | "light_red_underline" => Color::LightRed.underline(),
+            "lri" | "light_red_italic" => Color::LightRed.italic(),
+            "lrd" | "light_red_dimmed" => Color::LightRed.dimmed(),
+            "lrr" | "light_red_reverse" => Color::LightRed.reverse(),
+            "lrbl" | "light_red_blink" => Color::LightRed.blink(),
+            "lrst" | "light_red_strike" => Color::LightRed.strikethrough(),
+
+            "u" | "blue" => Color::Blue.normal(),
+            "ub" | "blue_bold" => Color::Blue.bold(),
+            "uu" | "blue_underline" => Color::Blue.underline(),
+            "ui" | "blue_italic" => Color::Blue.italic(),
+            "ud" | "blue_dimmed" => Color::Blue.dimmed(),
+            "ur" | "blue_reverse" => Color::Blue.reverse(),
+            "ubl" | "blue_blink" => Color::Blue.blink(),
+            "ust" | "blue_strike" => Color::Blue.strikethrough(),
+
+            "lu" | "light_blue" => Color::LightBlue.normal(),
+            "lub" | "light_blue_bold" => Color::LightBlue.bold(),
+            "luu" | "light_blue_underline" => Color::LightBlue.underline(),
+            "lui" | "light_blue_italic" => Color::LightBlue.italic(),
+            "lud" | "light_blue_dimmed" => Color::LightBlue.dimmed(),
+            "lur" | "light_blue_reverse" => Color::LightBlue.reverse(),
+            "lubl" | "light_blue_blink" => Color::LightBlue.blink(),
+            "lust" | "light_blue_strike" => Color::LightBlue.strikethrough(),
+
+            "b" | "black" => Color::Black.normal(),
+            "bb" | "black_bold" => Color::Black.bold(),
+            "bu" | "black_underline" => Color::Black.underline(),
+            "bi" | "black_italic" => Color::Black.italic(),
+            "bd" | "black_dimmed" => Color::Black.dimmed(),
+            "br" | "black_reverse" => Color::Black.reverse(),
+            "bbl" | "black_blink" => Color::Black.blink(),
+            "bst" | "black_strike" => Color::Black.strikethrough(),
+
+            "ligr" | "light_gray" => Color::LightGray.normal(),
+            "ligrb" | "light_gray_bold" => Color::LightGray.bold(),
+            "ligru" | "light_gray_underline" => Color::LightGray.underline(),
+            "ligri" | "light_gray_italic" => Color::LightGray.italic(),
+            "ligrd" | "light_gray_dimmed" => Color::LightGray.dimmed(),
+            "ligrr" | "light_gray_reverse" => Color::LightGray.reverse(),
+            "ligrbl" | "light_gray_blink" => Color::LightGray.blink(),
+            "ligrst" | "light_gray_strike" => Color::LightGray.strikethrough(),
+
+            "y" | "yellow" => Color::Yellow.normal(),
+            "yb" | "yellow_bold" => Color::Yellow.bold(),
+            "yu" | "yellow_underline" => Color::Yellow.underline(),
+            "yi" | "yellow_italic" => Color::Yellow.italic(),
+            "yd" | "yellow_dimmed" => Color::Yellow.dimmed(),
+            "yr" | "yellow_reverse" => Color::Yellow.reverse(),
+            "ybl" | "yellow_blink" => Color::Yellow.blink(),
+            "yst" | "yellow_strike" => Color::Yellow.strikethrough(),
+
+            "ly" | "light_yellow" => Color::LightYellow.normal(),
+            "lyb" | "light_yellow_bold" => Color::LightYellow.bold(),
+            "lyu" | "light_yellow_underline" => Color::LightYellow.underline(),
+            "lyi" | "light_yellow_italic" => Color::LightYellow.italic(),
+            "lyd" | "light_yellow_dimmed" => Color::LightYellow.dimmed(),
+            "lyr" | "light_yellow_reverse" => Color::LightYellow.reverse(),
+            "lybl" | "light_yellow_blink" => Color::LightYellow.blink(),
+            "lyst" | "light_yellow_strike" => Color::LightYellow.strikethrough(),
+
+            "p" | "purple" => Color::Purple.normal(),
+            "pb" | "purple_bold" => Color::Purple.bold(),
+            "pu" | "purple_underline" => Color::Purple.underline(),
+            "pi" | "purple_italic" => Color::Purple.italic(),
+            "pd" | "purple_dimmed" => Color::Purple.dimmed(),
+            "pr" | "purple_reverse" => Color::Purple.reverse(),
+            "pbl" | "purple_blink" => Color::Purple.blink(),
+            "pst" | "purple_strike" => Color::Purple.strikethrough(),
+
+            "lp" | "light_purple" => Color::LightPurple.normal(),
+            "lpb" | "light_purple_bold" => Color::LightPurple.bold(),
+            "lpu" | "light_purple_underline" => Color::LightPurple.underline(),
+            "lpi" | "light_purple_italic" => Color::LightPurple.italic(),
+            "lpd" | "light_purple_dimmed" => Color::LightPurple.dimmed(),
+            "lpr" | "light_purple_reverse" => Color::LightPurple.reverse(),
+            "lpbl" | "light_purple_blink" => Color::LightPurple.blink(),
+            "lpst" | "light_purple_strike" => Color::LightPurple.strikethrough(),
+
+            "c" | "cyan" => Color::Cyan.normal(),
+            "cb" | "cyan_bold" => Color::Cyan.bold(),
+            "cu" | "cyan_underline" => Color::Cyan.underline(),
+            "ci" | "cyan_italic" => Color::Cyan.italic(),
+            "cd" | "cyan_dimmed" => Color::Cyan.dimmed(),
+            "cr" | "cyan_reverse" => Color::Cyan.reverse(),
+            "cbl" | "cyan_blink" => Color::Cyan.blink(),
+            "cst" | "cyan_strike" => Color::Cyan.strikethrough(),
+
+            "lc" | "light_cyan" => Color::LightCyan.normal(),
+            "lcb" | "light_cyan_bold" => Color::LightCyan.bold(),
+            "lcu" | "light_cyan_underline" => Color::LightCyan.underline(),
+            "lci" | "light_cyan_italic" => Color::LightCyan.italic(),
+            "lcd" | "light_cyan_dimmed" => Color::LightCyan.dimmed(),
+            "lcr" | "light_cyan_reverse" => Color::LightCyan.reverse(),
+            "lcbl" | "light_cyan_blink" => Color::LightCyan.blink(),
+            "lcst" | "light_cyan_strike" => Color::LightCyan.strikethrough(),
+
+            "w" | "white" => Color::White.normal(),
+            "wb" | "white_bold" => Color::White.bold(),
+            "wu" | "white_underline" => Color::White.underline(),
+            "wi" | "white_italic" => Color::White.italic(),
+            "wd" | "white_dimmed" => Color::White.dimmed(),
+            "wr" | "white_reverse" => Color::White.reverse(),
+            "wbl" | "white_blink" => Color::White.blink(),
+            "wst" | "white_strike" => Color::White.strikethrough(),
+
+            "dgr" | "dark_gray" => Color::DarkGray.normal(),
+            "dgrb" | "dark_gray_bold" => Color::DarkGray.bold(),
+            "dgru" | "dark_gray_underline" => Color::DarkGray.underline(),
+            "dgri" | "dark_gray_italic" => Color::DarkGray.italic(),
+            "dgrd" | "dark_gray_dimmed" => Color::DarkGray.dimmed(),
+            "dgrr" | "dark_gray_reverse" => Color::DarkGray.reverse(),
+            "dgrbl" | "dark_gray_blink" => Color::DarkGray.blink(),
+            "dgrst" | "dark_gray_strike" => Color::DarkGray.strikethrough(),
+
+            _ => Color::White.normal(),
+        }
+    }
+}
+
+fn update_hashmap(key: &str, val: &str, hm: &mut HashMap<String, Style>) {
+    // eprintln!("key: {}, val: {}", &key, &val);
+    let color = lookup_ansi_color_style(val);
+    if let Some(v) = hm.get_mut(key) {
+        *v = color;
+    } else {
+        hm.insert(key.to_string(), color);
+    }
+}
+
+pub fn get_color_config(config: &Config) -> HashMap<String, Style> {
+    let config = config;
+
+    // create the hashmap
+    let mut hm: HashMap<String, Style> = HashMap::new();
+    // set some defaults
+    // hm.insert("primitive_line".to_string(), Color::White.normal());
+    // hm.insert("primitive_pattern".to_string(), Color::White.normal());
+    // hm.insert("primitive_path".to_string(), Color::White.normal());
+    hm.insert("separator".to_string(), Color::White.normal());
+    hm.insert(
+        "leading_trailing_space_bg".to_string(),
+        Style::default().on(Color::Rgb(128, 128, 128)),
+    );
+    hm.insert("header".to_string(), Color::Green.bold());
+    hm.insert("empty".to_string(), Color::Blue.normal());
+    hm.insert("bool".to_string(), Color::White.normal());
+    hm.insert("int".to_string(), Color::White.normal());
+    hm.insert("filesize".to_string(), Color::White.normal());
+    hm.insert("duration".to_string(), Color::White.normal());
+    hm.insert("date".to_string(), Color::White.normal());
+    hm.insert("range".to_string(), Color::White.normal());
+    hm.insert("float".to_string(), Color::White.normal());
+    hm.insert("string".to_string(), Color::White.normal());
+    hm.insert("nothing".to_string(), Color::White.normal());
+    hm.insert("binary".to_string(), Color::White.normal());
+    hm.insert("cellpath".to_string(), Color::White.normal());
+    hm.insert("row_index".to_string(), Color::Green.bold());
+    hm.insert("record".to_string(), Color::White.normal());
+    hm.insert("list".to_string(), Color::White.normal());
+    hm.insert("block".to_string(), Color::White.normal());
+    hm.insert("hints".to_string(), Color::DarkGray.normal());
+
+    for (key, value) in &config.color_config {
+        let value = value
+            .as_string()
+            .expect("the only values for config color must be strings");
+        update_hashmap(key, &value, &mut hm);
+
+        // eprintln!(
+        //     "config: {}:{}\t\t\thashmap: {}:{:?}",
+        //     &key, &value, &key, &hm[key]
+        // );
+    }
+
+    hm
+}
+
+// This function will assign a text style to a primitive, or really any string that's
+// in the hashmap. The hashmap actually contains the style to be applied.
+pub fn style_primitive(primitive: &str, color_hm: &HashMap<String, Style>) -> TextStyle {
+    match primitive {
+        "bool" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "int" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Right, *s),
+                None => TextStyle::basic_right(),
+            }
+        }
+
+        "filesize" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Right, *s),
+                None => TextStyle::basic_right(),
+            }
+        }
+
+        "duration" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "date" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "range" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "float" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Right, *s),
+                None => TextStyle::basic_right(),
+            }
+        }
+
+        "string" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "nothing" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        // not sure what to do with error
+        // "error" => {}
+        "binary" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "cellpath" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "row_index" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Right, *s),
+                None => TextStyle::new()
+                    .alignment(Alignment::Right)
+                    .fg(Color::Green)
+                    .bold(Some(true)),
+            }
+        }
+
+        "record" | "list" | "block" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        // types in nushell but not in engine-q
+        // "Line" => {
+        //     let style = color_hm.get("Primitive::Line");
+        //     match style {
+        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        //         None => TextStyle::basic_left(),
+        //     }
+        // }
+        // "GlobPattern" => {
+        //     let style = color_hm.get("Primitive::GlobPattern");
+        //     match style {
+        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        //         None => TextStyle::basic_left(),
+        //     }
+        // }
+        // "FilePath" => {
+        //     let style = color_hm.get("Primitive::FilePath");
+        //     match style {
+        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        //         None => TextStyle::basic_left(),
+        //     }
+        // }
+        // "BeginningOfStream" => {
+        //     let style = color_hm.get("Primitive::BeginningOfStream");
+        //     match style {
+        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        //         None => TextStyle::basic_left(),
+        //     }
+        // }
+        // "EndOfStream" => {
+        //     let style = color_hm.get("Primitive::EndOfStream");
+        //     match style {
+        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        //         None => TextStyle::basic_left(),
+        //     }
+        // }
+        _ => TextStyle::basic_left(),
+    }
+}
+
+#[test]
+fn test_hm() {
+    use nu_ansi_term::{Color, Style};
+
+    let mut hm: HashMap<String, Style> = HashMap::new();
+    hm.insert("primitive_int".to_string(), Color::White.normal());
+    hm.insert("primitive_decimal".to_string(), Color::White.normal());
+    hm.insert("primitive_filesize".to_string(), Color::White.normal());
+    hm.insert("primitive_string".to_string(), Color::White.normal());
+    hm.insert("primitive_line".to_string(), Color::White.normal());
+    hm.insert("primitive_columnpath".to_string(), Color::White.normal());
+    hm.insert("primitive_pattern".to_string(), Color::White.normal());
+    hm.insert("primitive_boolean".to_string(), Color::White.normal());
+    hm.insert("primitive_date".to_string(), Color::White.normal());
+    hm.insert("primitive_duration".to_string(), Color::White.normal());
+    hm.insert("primitive_range".to_string(), Color::White.normal());
+    hm.insert("primitive_path".to_string(), Color::White.normal());
+    hm.insert("primitive_binary".to_string(), Color::White.normal());
+    hm.insert("separator".to_string(), Color::White.normal());
+    hm.insert("header_align".to_string(), Color::Green.bold());
+    hm.insert("header".to_string(), Color::Green.bold());
+    hm.insert("header_style".to_string(), Style::default());
+    hm.insert("row_index".to_string(), Color::Green.bold());
+    hm.insert(
+        "leading_trailing_space_bg".to_string(),
+        Style::default().on(Color::Rgb(128, 128, 128)),
+    );
+
+    update_hashmap("primitive_int", "green", &mut hm);
+
+    assert_eq!(hm["primitive_int"], Color::Green.normal());
+}

crates/nu-color-config/src/lib.rs

@@ -0,0 +1,7 @@
+mod color_config;
+mod nu_style;
+mod shape_color;
+
+pub use color_config::*;
+pub use nu_style::*;
+pub use shape_color::*;

crates/nu-color-config/src/nu_style.rs

@@ -0,0 +1,103 @@
+use nu_ansi_term::{Color, Style};
+use serde::Deserialize;
+
+#[derive(Deserialize, PartialEq, Debug)]
+pub struct NuStyle {
+    pub fg: Option<String>,
+    pub bg: Option<String>,
+    pub attr: Option<String>,
+}
+
+pub fn parse_nustyle(nu_style: NuStyle) -> Style {
+    // get the nu_ansi_term::Color foreground color
+    let fg_color = match nu_style.fg {
+        Some(fg) => color_from_hex(&fg).expect("error with foreground color"),
+        _ => None,
+    };
+    // get the nu_ansi_term::Color background color
+    let bg_color = match nu_style.bg {
+        Some(bg) => color_from_hex(&bg).expect("error with background color"),
+        _ => None,
+    };
+    // get the attributes
+    let color_attr = match nu_style.attr {
+        Some(attr) => attr,
+        _ => "".to_string(),
+    };
+
+    // setup the attributes available in nu_ansi_term::Style
+    let mut bold = false;
+    let mut dimmed = false;
+    let mut italic = false;
+    let mut underline = false;
+    let mut blink = false;
+    let mut reverse = false;
+    let mut hidden = false;
+    let mut strikethrough = false;
+
+    // since we can combine styles like bold-italic, iterate through the chars
+    // and set the bools for later use in the nu_ansi_term::Style application
+    for ch in color_attr.to_lowercase().chars() {
+        match ch {
+            'l' => blink = true,
+            'b' => bold = true,
+            'd' => dimmed = true,
+            'h' => hidden = true,
+            'i' => italic = true,
+            'r' => reverse = true,
+            's' => strikethrough = true,
+            'u' => underline = true,
+            'n' => (),
+            _ => (),
+        }
+    }
+
+    // here's where we build the nu_ansi_term::Style
+    Style {
+        foreground: fg_color,
+        background: bg_color,
+        is_blink: blink,
+        is_bold: bold,
+        is_dimmed: dimmed,
+        is_hidden: hidden,
+        is_italic: italic,
+        is_reverse: reverse,
+        is_strikethrough: strikethrough,
+        is_underline: underline,
+    }
+}
+
+pub fn color_string_to_nustyle(color_string: String) -> Style {
+    // eprintln!("color_string: {}", &color_string);
+    if color_string.chars().count() < 1 {
+        Style::default()
+    } else {
+        let nu_style = match nu_json::from_str::<NuStyle>(&color_string) {
+            Ok(s) => s,
+            Err(_) => NuStyle {
+                fg: None,
+                bg: None,
+                attr: None,
+            },
+        };
+
+        parse_nustyle(nu_style)
+    }
+}
+
+pub fn color_from_hex(
+    hex_color: &str,
+) -> std::result::Result<Option<Color>, std::num::ParseIntError> {
+    // right now we only allow hex colors with hashtag and 6 characters
+    let trimmed = hex_color.trim_matches('#');
+    if trimmed.len() != 6 {
+        Ok(None)
+    } else {
+        // make a nu_ansi_term::Color::Rgb color by converting hex to decimal
+        Ok(Some(Color::Rgb(
+            u8::from_str_radix(&trimmed[..2], 16)?,
+            u8::from_str_radix(&trimmed[2..4], 16)?,
+            u8::from_str_radix(&trimmed[4..6], 16)?,
+        )))
+    }
+}

crates/nu-color-config/src/shape_color.rs

@@ -0,0 +1,40 @@
+use crate::color_config::lookup_ansi_color_style;
+use nu_ansi_term::{Color, Style};
+use nu_protocol::Config;
+
+pub fn get_shape_color(shape: String, conf: &Config) -> Style {
+    match conf.color_config.get(shape.as_str()) {
+        Some(int_color) => match int_color.as_string() {
+            Ok(int_color) => lookup_ansi_color_style(&int_color),
+            Err(_) => Style::default(),
+        },
+        None => match shape.as_ref() {
+            "shape_garbage" => Style::new().fg(Color::White).on(Color::Red).bold(),
+            "shape_binary" => Style::new().fg(Color::Purple).bold(),
+            "shape_bool" => Style::new().fg(Color::LightCyan),
+            "shape_int" => Style::new().fg(Color::Purple).bold(),
+            "shape_float" => Style::new().fg(Color::Purple).bold(),
+            "shape_range" => Style::new().fg(Color::Yellow).bold(),
+            "shape_internalcall" => Style::new().fg(Color::Cyan).bold(),
+            "shape_external" => Style::new().fg(Color::Cyan),
+            "shape_externalarg" => Style::new().fg(Color::Green).bold(),
+            "shape_literal" => Style::new().fg(Color::Blue),
+            "shape_operator" => Style::new().fg(Color::Yellow),
+            "shape_signature" => Style::new().fg(Color::Green).bold(),
+            "shape_string" => Style::new().fg(Color::Green),
+            "shape_string_interpolation" => Style::new().fg(Color::Cyan).bold(),
+            "shape_datetime" => Style::new().fg(Color::Cyan).bold(),
+            "shape_list" => Style::new().fg(Color::Cyan).bold(),
+            "shape_table" => Style::new().fg(Color::Blue).bold(),
+            "shape_record" => Style::new().fg(Color::Cyan).bold(),
+            "shape_block" => Style::new().fg(Color::Blue).bold(),
+            "shape_filepath" => Style::new().fg(Color::Cyan),
+            "shape_globpattern" => Style::new().fg(Color::Cyan).bold(),
+            "shape_variable" => Style::new().fg(Color::Purple),
+            "shape_flag" => Style::new().fg(Color::Blue).bold(),
+            "shape_custom" => Style::new().fg(Color::Green),
+            "shape_nothing" => Style::new().fg(Color::LightCyan),
+            _ => Style::default(),
+        },
+    }
+}

crates/nu-command/Cargo.toml

@@ -0,0 +1,108 @@
+[package]
+name = "nu-command"
+version = "0.60.0"
+edition = "2021"
+build = "build.rs"
+
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+nu-color-config = { path = "../nu-color-config", version = "0.60.0"  }
+nu-engine = { path = "../nu-engine", version = "0.60.0"  }
+nu-glob = { path = "../nu-glob", version = "0.60.0" }
+nu-json = { path = "../nu-json", version = "0.60.0"  }
+nu-parser = { path = "../nu-parser", version = "0.60.0"  }
+nu-path = { path = "../nu-path", version = "0.60.0"  }
+nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.60.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.60.0"  }
+nu-system = { path = "../nu-system", version = "0.60.0"  }
+nu-table = { path = "../nu-table", version = "0.60.0"  }
+nu-term-grid = { path = "../nu-term-grid", version = "0.60.0"  }
+nu-test-support = { path = "../nu-test-support", version = "0.60.0"  }
+nu-utils = { path = "../nu-utils", version = "0.60.0" }
+nu-ansi-term = "0.45.0"
+
+# Potential dependencies for extras
+base64 = "0.13.0"
+bytesize = "1.1.0"
+calamine = "0.18.0"
+chrono = { version = "0.4.19", features = ["serde"] }
+chrono-humanize = "0.2.1"
+chrono-tz = "0.6.0"
+crossterm = "0.23.0"
+csv = "1.1.3"
+dialoguer = "0.9.0"
+digest = "0.10.0"
+dtparse = "1.2.0"
+eml-parser = "0.1.0"
+encoding_rs = "0.8.30"
+filesize = "0.2.0"
+fs_extra = "1.2.0"
+htmlescape = "0.3.1"
+ical = "0.7.0"
+indexmap = { version="1.7", features=["serde-1"] }
+Inflector = "0.11"
+itertools = "0.10.0"
+lazy_static = "1.4.0"
+log = "0.4.14"
+lscolors = { version = "0.9.0", features = ["crossterm"]}
+md5 = { package = "md-5", version = "0.10.0" }
+meval = "0.2.0"
+mime = "0.3.16"
+num = { version = "0.4.0", optional = true }
+pathdiff = "0.2.1"
+quick-xml = "0.22"
+rand = "0.8"
+rayon = "1.5.1"
+regex = "1.5.4"
+reqwest = {version = "0.11", features = ["blocking", "json"] }
+roxmltree = "0.14.0"
+rust-embed = "6.3.0"
+serde = { version="1.0.123", features=["derive"] }
+serde_ini = "0.2.0"
+serde_urlencoded = "0.7.0"
+serde_yaml = "0.8.16"
+sha2 = "0.10.0"
+shadow-rs = "0.8.1"
+strip-ansi-escapes = "0.1.1"
+sysinfo = "0.23.5"
+terminal_size = "0.1.17"
+thiserror = "1.0.29"
+titlecase = "1.1.0"
+toml = "0.5.8"
+trash = { version = "2.0.2", optional = true }
+unicode-segmentation = "1.8.0"
+url = "2.2.1"
+uuid = { version = "0.8.2", features = ["v4"] }
+which = { version = "4.2.2", optional = true }
+reedline = "0.3.0"
+zip = { version="0.5.9", optional = true }
+
+[target.'cfg(unix)'.dependencies]
+umask = "1.0.0"
+users = "0.11.0"
+
+[dependencies.polars]
+version = "0.20.0"
+optional = true
+features = [
+	"default", "parquet", "json", "serde", "object",
+	"checked_arithmetic", "strings", "cum_agg", "is_in",
+	"rolling_window", "strings", "rows", "random",
+    "dtype-datetime"
+]
+
+[features]
+trash-support = ["trash"]
+plugin = ["nu-parser/plugin"]
+dataframe = ["polars", "num"]
+
+[build-dependencies]
+shadow-rs = "0.8.1"
+
+[dev-dependencies]
+hamcrest2 = "0.3.0"
+dirs-next = "2.0.0"
+quickcheck = "1.0.3"
+quickcheck_macros = "1.0.0"

crates/nu-command/build.rs

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

crates/nu-command/src/conversions/fmt.rs

@@ -0,0 +1,176 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Span, Value,
+};
+
+#[derive(Clone)]
+pub struct Fmt;
+
+impl Command for Fmt {
+    fn name(&self) -> &str {
+        "fmt"
+    }
+
+    fn usage(&self) -> &str {
+        "format numbers"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("fmt").category(Category::Conversions)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "format numbers",
+            example: "42 | fmt",
+            result: Some(Value::Record {
+                cols: vec![
+                    "binary".into(),
+                    "debug".into(),
+                    "display".into(),
+                    "lowerexp".into(),
+                    "lowerhex".into(),
+                    "octal".into(),
+                    "upperexp".into(),
+                    "upperhex".into(),
+                ],
+                vals: vec![
+                    Value::String {
+                        val: "0b101010".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "42".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "42".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "4.2e1".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "0x2a".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "0o52".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "4.2E1".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "0x2A".to_string(),
+                        span: Span::test_data(),
+                    },
+                ],
+                span: Span::test_data(),
+            }),
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        fmt(engine_state, stack, call, input)
+    }
+}
+
+fn fmt(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+    let head = call.head;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+
+    input.map(
+        move |v| {
+            if column_paths.is_empty() {
+                action(&v, head)
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    let r =
+                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+pub fn action(input: &Value, span: Span) -> Value {
+    match input {
+        Value::Int { val, .. } => fmt_it(*val, span),
+        Value::Filesize { val, .. } => fmt_it(*val, span),
+        _ => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!("unsupported input type: {:?}", input.get_type()),
+                span,
+            ),
+        },
+    }
+}
+
+fn fmt_it(num: i64, span: Span) -> Value {
+    let mut cols = vec![];
+    let mut vals = vec![];
+
+    cols.push("binary".into());
+    vals.push(Value::string(format!("{:#b}", num), span));
+
+    cols.push("debug".into());
+    vals.push(Value::string(format!("{:#?}", num), span));
+
+    cols.push("display".into());
+    vals.push(Value::string(format!("{}", num), span));
+
+    cols.push("lowerexp".into());
+    vals.push(Value::string(format!("{:#e}", num), span));
+
+    cols.push("lowerhex".into());
+    vals.push(Value::string(format!("{:#x}", num), span));
+
+    cols.push("octal".into());
+    vals.push(Value::string(format!("{:#o}", num), span));
+
+    // cols.push("pointer".into());
+    // vals.push(Value::string(format!("{:#p}", &num), span));
+
+    cols.push("upperexp".into());
+    vals.push(Value::string(format!("{:#E}", num), span));
+
+    cols.push("upperhex".into());
+    vals.push(Value::string(format!("{:#X}", num), span));
+
+    Value::Record { cols, vals, span }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(Fmt {})
+    }
+}

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

@@ -0,0 +1,203 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "into binary"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into binary")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "column paths to convert to binary (for table input)",
+            )
+            .category(Category::Conversions)
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to a binary primitive"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        into_binary(engine_state, stack, call, input)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "convert string to a nushell binary primitive",
+                example: "'This is a string that is exactly 52 characters long.' | into binary",
+                result: Some(Value::Binary {
+                    val: "This is a string that is exactly 52 characters long."
+                        .to_string()
+                        .as_bytes()
+                        .to_vec(),
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "convert a number to a nushell binary primitive",
+                example: "1 | into binary",
+                result: Some(Value::Binary {
+                    val: i64::from(1).to_le_bytes().to_vec(),
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "convert a boolean to a nushell binary primitive",
+                example: "true | into binary",
+                result: Some(Value::Binary {
+                    val: i64::from(1).to_le_bytes().to_vec(),
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "convert a filesize to a nushell binary primitive",
+                example: "ls | where name == LICENSE | get size | into binary",
+                result: None,
+            },
+            Example {
+                description: "convert a filepath to a nushell binary primitive",
+                example: "ls | where name == LICENSE | get name | path expand | into binary",
+                result: None,
+            },
+            Example {
+                description: "convert a decimal to a nushell binary primitive",
+                example: "1.234 | into binary",
+                result: Some(Value::Binary {
+                    val: 1.234f64.to_le_bytes().to_vec(),
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn into_binary(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+    let head = call.head;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+
+    match input {
+        PipelineData::ExternalStream { stdout: None, .. } => Ok(Value::Binary {
+            val: vec![],
+            span: head,
+        }
+        .into_pipeline_data()),
+        PipelineData::ExternalStream {
+            stdout: Some(stream),
+            ..
+        } => {
+            // TODO: in the future, we may want this to stream out, converting each to bytes
+            let output = stream.into_bytes()?;
+            Ok(Value::Binary {
+                val: output.item,
+                span: head,
+            }
+            .into_pipeline_data())
+        }
+        _ => input.map(
+            move |v| {
+                if column_paths.is_empty() {
+                    action(&v, head)
+                } else {
+                    let mut ret = v;
+                    for path in &column_paths {
+                        let r = ret.update_cell_path(
+                            &path.members,
+                            Box::new(move |old| action(old, head)),
+                        );
+                        if let Err(error) = r {
+                            return Value::Error { error };
+                        }
+                    }
+
+                    ret
+                }
+            },
+            engine_state.ctrlc.clone(),
+        ),
+    }
+}
+
+fn int_to_endian(n: i64) -> Vec<u8> {
+    if cfg!(target_endian = "little") {
+        n.to_le_bytes().to_vec()
+    } else {
+        n.to_be_bytes().to_vec()
+    }
+}
+
+fn float_to_endian(n: f64) -> Vec<u8> {
+    if cfg!(target_endian = "little") {
+        n.to_le_bytes().to_vec()
+    } else {
+        n.to_be_bytes().to_vec()
+    }
+}
+
+pub fn action(input: &Value, span: Span) -> Value {
+    match input {
+        Value::Binary { .. } => input.clone(),
+        Value::Int { val, .. } => Value::Binary {
+            val: int_to_endian(*val),
+            span,
+        },
+        Value::Float { val, .. } => Value::Binary {
+            val: float_to_endian(*val),
+            span,
+        },
+        Value::Filesize { val, .. } => Value::Binary {
+            val: int_to_endian(*val),
+            span,
+        },
+        Value::String { val, .. } => Value::Binary {
+            val: val.as_bytes().to_vec(),
+            span,
+        },
+        Value::Bool { val, .. } => Value::Binary {
+            val: int_to_endian(if *val { 1i64 } else { 0 }),
+            span,
+        },
+        Value::Date { val, .. } => Value::Binary {
+            val: val.format("%c").to_string().as_bytes().to_vec(),
+            span,
+        },
+
+        _ => Value::Error {
+            error: ShellError::UnsupportedInput("'into binary' for unsupported type".into(), span),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

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

@@ -0,0 +1,183 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "into bool"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into bool")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "column paths to convert to boolean (for table input)",
+            )
+            .category(Category::Conversions)
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to boolean"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        into_bool(engine_state, stack, call, input)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        let span = Span::test_data();
+        vec![
+            Example {
+                description: "Convert value to boolean in table",
+                example: "echo [[value]; ['false'] ['1'] [0] [1.0] [true]] | into bool value",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::Record {
+                            cols: vec!["value".to_string()],
+                            vals: vec![Value::boolean(false, span)],
+                            span,
+                        },
+                        Value::Record {
+                            cols: vec!["value".to_string()],
+                            vals: vec![Value::boolean(true, span)],
+                            span,
+                        },
+                        Value::Record {
+                            cols: vec!["value".to_string()],
+                            vals: vec![Value::boolean(false, span)],
+                            span,
+                        },
+                        Value::Record {
+                            cols: vec!["value".to_string()],
+                            vals: vec![Value::boolean(true, span)],
+                            span,
+                        },
+                        Value::Record {
+                            cols: vec!["value".to_string()],
+                            vals: vec![Value::boolean(true, span)],
+                            span,
+                        },
+                    ],
+                    span,
+                }),
+            },
+            Example {
+                description: "Convert bool to boolean",
+                example: "true | into bool",
+                result: Some(Value::boolean(true, span)),
+            },
+            Example {
+                description: "convert integer to boolean",
+                example: "1 | into bool",
+                result: Some(Value::boolean(true, span)),
+            },
+            Example {
+                description: "convert decimal string to boolean",
+                example: "'0.0' | into bool",
+                result: Some(Value::boolean(false, span)),
+            },
+            Example {
+                description: "convert string to boolean",
+                example: "'true' | into bool",
+                result: Some(Value::boolean(true, span)),
+            },
+        ]
+    }
+}
+
+fn into_bool(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let head = call.head;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+
+    input.map(
+        move |v| {
+            if column_paths.is_empty() {
+                action(&v, head)
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    let r =
+                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+fn string_to_boolean(s: &str, span: Span) -> Result<bool, ShellError> {
+    match s.trim().to_lowercase().as_str() {
+        "true" => Ok(true),
+        "false" => Ok(false),
+        o => {
+            let val = o.parse::<f64>();
+            match val {
+                Ok(f) => Ok(f.abs() >= f64::EPSILON),
+                Err(_) => Err(ShellError::CantConvert(
+                    "boolean".to_string(),
+                    "string".to_string(),
+                    span,
+                )),
+            }
+        }
+    }
+}
+
+fn action(input: &Value, span: Span) -> Value {
+    match input {
+        Value::Bool { .. } => input.clone(),
+        Value::Int { val, .. } => Value::Bool {
+            val: *val != 0,
+            span,
+        },
+        Value::Float { val, .. } => Value::Bool {
+            val: val.abs() >= f64::EPSILON,
+            span,
+        },
+        Value::String { val, .. } => match string_to_boolean(val, span) {
+            Ok(val) => Value::Bool { val, span },
+            Err(error) => Value::Error { error },
+        },
+        _ => Value::Error {
+            error: ShellError::UnsupportedInput(
+                "'into bool' does not support this input".into(),
+                span,
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

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

@@ -0,0 +1,49 @@
+use nu_engine::get_full_help;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, Signature, Value,
+};
+
+#[derive(Clone)]
+pub struct Into;
+
+impl Command for Into {
+    fn name(&self) -> &str {
+        "into"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into").category(Category::Conversions)
+    }
+
+    fn usage(&self) -> &str {
+        "Apply into function."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(Value::String {
+            val: get_full_help(&Into.signature(), &[], engine_state, stack),
+            span: call.head,
+        }
+        .into_pipeline_data())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(Into {})
+    }
+}

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

@@ -0,0 +1,385 @@
+use chrono::{DateTime, FixedOffset, Local, TimeZone, Utc};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::ast::CellPath;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
+};
+
+use crate::generate_strftime_list;
+use crate::parse_date_from_string;
+
+struct Arguments {
+    timezone: Option<Spanned<String>>,
+    offset: Option<Spanned<i64>>,
+    format: Option<String>,
+    column_paths: Vec<CellPath>,
+}
+
+// In case it may be confused with chrono::TimeZone
+#[derive(Clone, Debug)]
+enum Zone {
+    Utc,
+    Local,
+    East(u8),
+    West(u8),
+    Error, // we want the nullshell to cast it instead of rust
+}
+
+impl Zone {
+    fn new(i: i64) -> Self {
+        if i.abs() <= 12 {
+            // guanranteed here
+            if i >= 0 {
+                Self::East(i as u8) // won't go out of range
+            } else {
+                Self::West(-i as u8) // same here
+            }
+        } else {
+            Self::Error // Out of range
+        }
+    }
+    fn from_string(s: String) -> Self {
+        match s.to_lowercase().as_str() {
+            "utc" | "u" => Self::Utc,
+            "local" | "l" => Self::Local,
+            _ => Self::Error,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "into datetime"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into datetime")
+            .switch(
+                "list",
+                "lists strftime cheatsheet",
+                Some('l'),
+                )
+            .named(
+                "timezone",
+                SyntaxShape::String,
+                "Specify timezone if the input is timestamp, like 'UTC/u' or 'LOCAL/l'",
+                Some('z'),
+            )
+            .named(
+                "offset",
+                SyntaxShape::Int,
+                "Specify timezone by offset if the input is timestamp, like '+8', '-4', prior than timezone",
+                Some('o'),
+            )
+            .named(
+                "format",
+                SyntaxShape::String,
+                "Specify date and time formatting",
+                Some('f'),
+            )
+            .rest(
+            "rest",
+                SyntaxShape::CellPath,
+                "optionally convert text into datetime by column paths",
+            )
+            .category(Category::Conversions)
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        operate(engine_state, stack, call, input)
+    }
+
+    fn usage(&self) -> &str {
+        "converts text into datetime"
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert to datetime",
+                example: "'16.11.1984 8:00 am +0000' | into datetime",
+                result: None,
+            },
+            Example {
+                description: "Convert to datetime",
+                example: "'2020-08-04T16:39:18+00:00' | into datetime",
+                result: None,
+            },
+            Example {
+                description: "Convert to datetime using a custom format",
+                example: "'20200904_163918+0000' | into datetime -f '%Y%m%d_%H%M%S%z'",
+                result: None,
+            },
+            Example {
+                description: "Convert timestamp (no larger than 8e+12) to datetime using a specified timezone",
+                example: "'1614434140' | into datetime -z 'UTC'",
+                result: None,
+            },
+            Example {
+                description:
+                    "Convert timestamp (no larger than 8e+12) to datetime using a specified timezone offset (between -12 and 12)",
+                example: "'1614434140' | into datetime -o +9",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[derive(Clone)]
+struct DatetimeFormat(String);
+
+fn operate(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let head = call.head;
+
+    let options = Arguments {
+        timezone: call.get_flag(engine_state, stack, "timezone")?,
+        offset: call.get_flag(engine_state, stack, "offset")?,
+        format: call.get_flag(engine_state, stack, "format")?,
+        column_paths: call.rest(engine_state, stack, 0)?,
+    };
+
+    // if zone-offset is specified, then zone will be neglected
+    let zone_options = match &options.offset {
+        Some(zone_offset) => Some(Spanned {
+            item: Zone::new(zone_offset.item),
+            span: zone_offset.span,
+        }),
+        None => options.timezone.as_ref().map(|zone| Spanned {
+            item: Zone::from_string(zone.item.clone()),
+            span: zone.span,
+        }),
+    };
+
+    let list_flag = call.has_flag("list");
+
+    let format_options = options
+        .format
+        .as_ref()
+        .map(|fmt| DatetimeFormat(fmt.to_string()));
+
+    input.map(
+        move |v| {
+            if options.column_paths.is_empty() && !list_flag {
+                action(&v, &zone_options, &format_options, head)
+            } else if list_flag {
+                generate_strftime_list(head, true)
+            } else {
+                let mut ret = v;
+                for path in &options.column_paths {
+                    let zone_options = zone_options.clone();
+                    let format_options = format_options.clone();
+                    let r = ret.update_cell_path(
+                        &path.members,
+                        Box::new(move |old| action(old, &zone_options, &format_options, head)),
+                    );
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+fn action(
+    input: &Value,
+    timezone: &Option<Spanned<Zone>>,
+    dateformat: &Option<DatetimeFormat>,
+    head: Span,
+) -> Value {
+    match input {
+        Value::String { val: s, span } => {
+            let ts = s.parse::<i64>();
+            // if timezone if specified, first check if the input is a timestamp.
+            if let Some(tz) = timezone {
+                const TIMESTAMP_BOUND: i64 = 8.2e+12 as i64;
+                // Since the timestamp method of chrono itself don't throw an error (it just panicked)
+                // We have to manually guard it.
+                if let Ok(t) = ts {
+                    if t.abs() > TIMESTAMP_BOUND {
+                        return Value::Error{error: ShellError::UnsupportedInput(
+                            "Given timestamp is out of range, it should between -8e+12 and 8e+12".to_string(),
+                            head,
+                        )};
+                    }
+                    const HOUR: i32 = 3600;
+                    let stampout = match tz.item {
+                        Zone::Utc => Value::Date {
+                            val: Utc.timestamp(t, 0).into(),
+                            span: head,
+                        },
+                        Zone::Local => Value::Date {
+                            val: Local.timestamp(t, 0).into(),
+                            span: head,
+                        },
+                        Zone::East(i) => {
+                            let eastoffset = FixedOffset::east((i as i32) * HOUR);
+                            Value::Date {
+                                val: eastoffset.timestamp(t, 0),
+                                span: head,
+                            }
+                        }
+                        Zone::West(i) => {
+                            let westoffset = FixedOffset::west((i as i32) * HOUR);
+                            Value::Date {
+                                val: westoffset.timestamp(t, 0),
+                                span: head,
+                            }
+                        }
+                        Zone::Error => Value::Error {
+                            error: ShellError::UnsupportedInput(
+                                "Cannot convert given timezone or offset to timestamp".to_string(),
+                                tz.span,
+                            ),
+                        },
+                    };
+                    return stampout;
+                }
+            };
+            // if it's not, continue and default to the system's local timezone.
+            let out = match dateformat {
+                Some(dt) => match DateTime::parse_from_str(s, &dt.0) {
+                    Ok(d) => Value::Date { val: d, span: head },
+                    Err(reason) => {
+                        return Value::Error {
+                            error: ShellError::CantConvert(
+                                format!("could not parse as datetime using format '{}'", dt.0),
+                                reason.to_string(),
+                                head,
+                            ),
+                        }
+                    }
+                },
+                // Tries to automatically parse the date
+                // (i.e. without a format string)
+                // and assumes the system's local timezone if none is specified
+                None => match parse_date_from_string(s, *span) {
+                    Ok(date) => Value::Date {
+                        val: date,
+                        span: *span,
+                    },
+                    Err(err) => err,
+                },
+            };
+
+            out
+        }
+        other => {
+            let got = format!("Expected string, got {} instead", other.get_type());
+            Value::Error {
+                error: ShellError::UnsupportedInput(got, head),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use super::{action, DatetimeFormat, SubCommand, Zone};
+    use nu_protocol::Type::Error;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+
+    #[test]
+    fn takes_a_date_format() {
+        let date_str = Value::test_string("16.11.1984 8:00 am +0000");
+        let fmt_options = Some(DatetimeFormat("%d.%m.%Y %H:%M %P %z".to_string()));
+        let actual = action(&date_str, &None, &fmt_options, Span::test_data());
+        let expected = Value::Date {
+            val: DateTime::parse_from_str("16.11.1984 8:00 am +0000", "%d.%m.%Y %H:%M %P %z")
+                .unwrap(),
+            span: Span::test_data(),
+        };
+        assert_eq!(actual, expected)
+    }
+
+    #[test]
+    fn takes_iso8601_date_format() {
+        let date_str = Value::test_string("2020-08-04T16:39:18+00:00");
+        let actual = action(&date_str, &None, &None, Span::test_data());
+        let expected = Value::Date {
+            val: DateTime::parse_from_str("2020-08-04T16:39:18+00:00", "%Y-%m-%dT%H:%M:%S%z")
+                .unwrap(),
+            span: Span::test_data(),
+        };
+        assert_eq!(actual, expected)
+    }
+
+    #[test]
+    fn takes_timestamp_offset() {
+        let date_str = Value::test_string("1614434140");
+        let timezone_option = Some(Spanned {
+            item: Zone::East(8),
+            span: Span::test_data(),
+        });
+        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
+        let expected = Value::Date {
+            val: DateTime::parse_from_str("2021-02-27 21:55:40 +08:00", "%Y-%m-%d %H:%M:%S %z")
+                .unwrap(),
+            span: Span::test_data(),
+        };
+
+        assert_eq!(actual, expected)
+    }
+
+    #[test]
+    fn takes_timestamp() {
+        let date_str = Value::test_string("1614434140");
+        let timezone_option = Some(Spanned {
+            item: Zone::Local,
+            span: Span::test_data(),
+        });
+        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
+        let expected = Value::Date {
+            val: Local.timestamp(1614434140, 0).into(),
+            span: Span::test_data(),
+        };
+
+        assert_eq!(actual, expected)
+    }
+
+    #[test]
+    fn takes_invalid_timestamp() {
+        let date_str = Value::test_string("10440970000000");
+        let timezone_option = Some(Spanned {
+            item: Zone::Utc,
+            span: Span::test_data(),
+        });
+        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
+
+        assert_eq!(actual.get_type(), Error);
+    }
+
+    #[test]
+    fn communicates_parsing_error_given_an_invalid_datetimelike_string() {
+        let date_str = Value::test_string("16.11.1984 8:00 am Oops0000");
+        let fmt_options = Some(DatetimeFormat("%d.%m.%Y %H:%M %P %z".to_string()));
+        let actual = action(&date_str, &None, &fmt_options, Span::test_data());
+
+        assert_eq!(actual.get_type(), Error);
+    }
+}

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

@@ -0,0 +1,166 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "into decimal"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into decimal").rest(
+            "rest",
+            SyntaxShape::CellPath,
+            "optionally convert text into decimal by column paths",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "converts text into decimal"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        operate(engine_state, stack, call, input)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to integer in table",
+                example: "[[num]; ['5.01']] | into decimal num",
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["num".to_string()],
+                        vals: vec![Value::test_float(5.01)],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Convert string to integer",
+                example: "'1.345' | into decimal",
+                result: Some(Value::test_float(1.345)),
+            },
+            Example {
+                description: "Convert decimal to integer",
+                example: "'-5.9' | into decimal",
+                result: Some(Value::test_float(-5.9)),
+            },
+        ]
+    }
+}
+
+fn operate(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+    let head = call.head;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+
+    input.map(
+        move |v| {
+            if column_paths.is_empty() {
+                action(&v, head)
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    let r =
+                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+fn action(input: &Value, head: Span) -> Value {
+    match input {
+        Value::String { val: s, span } => {
+            let other = s.trim();
+
+            match other.parse::<f64>() {
+                Ok(x) => Value::Float { val: x, span: head },
+                Err(reason) => Value::Error {
+                    error: ShellError::CantConvert("float".to_string(), reason.to_string(), *span),
+                },
+            }
+        }
+        Value::Int { val: v, span } => Value::Float {
+            val: *v as f64,
+            span: *span,
+        },
+        other => {
+            let span = other.span();
+            match span {
+                Ok(s) => {
+                    let got = format!("Expected a string, got {} instead", other.get_type());
+                    Value::Error {
+                        error: ShellError::UnsupportedInput(got, s),
+                    }
+                }
+                Err(e) => Value::Error { error: e },
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use nu_protocol::Type::Error;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+
+    #[test]
+    #[allow(clippy::approx_constant)]
+    fn string_to_decimal() {
+        let word = Value::test_string("3.1415");
+        let expected = Value::test_float(3.1415);
+
+        let actual = action(&word, Span::test_data());
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn communicates_parsing_error_given_an_invalid_decimallike_string() {
+        let decimal_str = Value::test_string("11.6anra");
+
+        let actual = action(&decimal_str, Span::test_data());
+
+        assert_eq!(actual.get_type(), Error);
+    }
+
+    #[test]
+    fn int_to_decimal() {
+        let decimal_str = Value::test_int(10);
+        let expected = Value::test_float(10.0);
+        let actual = action(&decimal_str, Span::test_data());
+
+        assert_eq!(actual, expected);
+    }
+}

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

@@ -0,0 +1,288 @@
+use nu_engine::CallExt;
+use nu_parser::parse_duration_bytes;
+use nu_protocol::{
+    ast::{Call, CellPath, Expr},
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Unit, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "into duration"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into duration")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "column paths to convert to duration (for table input)",
+            )
+            .category(Category::Conversions)
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to duration"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        into_duration(engine_state, stack, call, input)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        let span = Span::test_data();
+        vec![
+            Example {
+                description: "Convert string to duration in table",
+                example: "echo [[value]; ['1sec'] ['2min'] ['3hr'] ['4day'] ['5wk']] | into duration value",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::Record {
+                            cols: vec!["value".to_string()],
+                            vals: vec![Value::Duration {
+                                val: 1000 * 1000 * 1000,
+                                span,
+                            }],
+                            span,
+                        },
+                        Value::Record {
+                            cols: vec!["value".to_string()],
+                            vals: vec![Value::Duration {
+                                val: 2 * 60 * 1000 * 1000 * 1000,
+                                span,
+                            }],
+                            span,
+                        },
+                        Value::Record {
+                            cols: vec!["value".to_string()],
+                            vals: vec![Value::Duration {
+                                val: 3 * 60 * 60 * 1000 * 1000 * 1000,
+                                span,
+                            }],
+                            span,
+                        },
+                        Value::Record {
+                            cols: vec!["value".to_string()],
+                            vals: vec![Value::Duration {
+                                val: 4 * 24 * 60 * 60 * 1000 * 1000 * 1000,
+                                span,
+                            }],
+                            span,
+                        },
+                        Value::Record {
+                            cols: vec!["value".to_string()],
+                            vals: vec![Value::Duration {
+                                val: 5 * 7 * 24 * 60 * 60 * 1000 * 1000 * 1000,
+                                span,
+                            }],
+                            span,
+                        },
+                    ],
+                    span,
+                }),
+            },
+            Example {
+                description: "Convert string to duration",
+                example: "'7min' | into duration",
+                result: Some(Value::Duration {
+                    val: 7 * 60 * 1000 * 1000 * 1000,
+                    span,
+                }),
+            },
+        ]
+    }
+}
+
+fn into_duration(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let head = call.head;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+
+    input.map(
+        move |v| {
+            if column_paths.is_empty() {
+                action(&v, head)
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    let r =
+                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+fn string_to_duration(s: &str, span: Span) -> Result<i64, ShellError> {
+    if let Some(expression) = parse_duration_bytes(s.as_bytes(), span) {
+        if let Expr::ValueWithUnit(value, unit) = expression.expr {
+            if let Expr::Int(x) = value.expr {
+                match unit.item {
+                    Unit::Nanosecond => return Ok(x),
+                    Unit::Microsecond => return Ok(x * 1000),
+                    Unit::Millisecond => return Ok(x * 1000 * 1000),
+                    Unit::Second => return Ok(x * 1000 * 1000 * 1000),
+                    Unit::Minute => return Ok(x * 60 * 1000 * 1000 * 1000),
+                    Unit::Hour => return Ok(x * 60 * 60 * 1000 * 1000 * 1000),
+                    Unit::Day => return Ok(x * 24 * 60 * 60 * 1000 * 1000 * 1000),
+                    Unit::Week => return Ok(x * 7 * 24 * 60 * 60 * 1000 * 1000 * 1000),
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    Err(ShellError::CantConvert(
+        "duration".to_string(),
+        "string".to_string(),
+        span,
+    ))
+}
+
+fn action(input: &Value, span: Span) -> Value {
+    match input {
+        Value::Duration { .. } => input.clone(),
+        Value::String { val, .. } => match string_to_duration(val, span) {
+            Ok(val) => Value::Duration { val, span },
+            Err(error) => Value::Error { error },
+        },
+        _ => Value::Error {
+            error: ShellError::UnsupportedInput(
+                "'into duration' does not support this input".into(),
+                span,
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+
+    #[test]
+    fn turns_ns_to_duration() {
+        let span = Span::test_data();
+        let word = Value::test_string("3ns");
+        let expected = Value::Duration { val: 3, span };
+
+        let actual = action(&word, span);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn turns_us_to_duration() {
+        let span = Span::test_data();
+        let word = Value::test_string("4us");
+        let expected = Value::Duration {
+            val: 4 * 1000,
+            span,
+        };
+
+        let actual = action(&word, span);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn turns_ms_to_duration() {
+        let span = Span::test_data();
+        let word = Value::test_string("5ms");
+        let expected = Value::Duration {
+            val: 5 * 1000 * 1000,
+            span,
+        };
+
+        let actual = action(&word, span);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn turns_sec_to_duration() {
+        let span = Span::test_data();
+        let word = Value::test_string("1sec");
+        let expected = Value::Duration {
+            val: 1000 * 1000 * 1000,
+            span,
+        };
+
+        let actual = action(&word, span);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn turns_min_to_duration() {
+        let span = Span::test_data();
+        let word = Value::test_string("7min");
+        let expected = Value::Duration {
+            val: 7 * 60 * 1000 * 1000 * 1000,
+            span,
+        };
+
+        let actual = action(&word, span);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn turns_hr_to_duration() {
+        let span = Span::test_data();
+        let word = Value::test_string("42hr");
+        let expected = Value::Duration {
+            val: 42 * 60 * 60 * 1000 * 1000 * 1000,
+            span,
+        };
+
+        let actual = action(&word, span);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn turns_day_to_duration() {
+        let span = Span::test_data();
+        let word = Value::test_string("123day");
+        let expected = Value::Duration {
+            val: 123 * 24 * 60 * 60 * 1000 * 1000 * 1000,
+            span,
+        };
+
+        let actual = action(&word, span);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn turns_wk_to_duration() {
+        let span = Span::test_data();
+        let word = Value::test_string("3wk");
+        let expected = Value::Duration {
+            val: 3 * 7 * 24 * 60 * 60 * 1000 * 1000 * 1000,
+            span,
+        };
+
+        let actual = action(&word, span);
+        assert_eq!(actual, expected);
+    }
+}

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

@@ -0,0 +1,165 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "into filesize"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into filesize")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "column paths to convert to filesize (for table input)",
+            )
+            .category(Category::Conversions)
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to filesize"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        into_filesize(engine_state, stack, call, input)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to filesize in table",
+                example: "[[bytes]; ['5'] [3.2] [4] [2kb]] | into filesize bytes",
+                result: None,
+            },
+            Example {
+                description: "Convert string to filesize",
+                example: "'2' | into filesize",
+                result: Some(Value::Filesize {
+                    val: 2,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Convert decimal to filesize",
+                example: "8.3 | into filesize",
+                result: Some(Value::Filesize {
+                    val: 8,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Convert int to filesize",
+                example: "5 | into filesize",
+                result: Some(Value::Filesize {
+                    val: 5,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Convert file size to filesize",
+                example: "4KB | into filesize",
+                result: Some(Value::Filesize {
+                    val: 4000,
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn into_filesize(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+    let head = call.head;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+
+    input.map(
+        move |v| {
+            if column_paths.is_empty() {
+                action(&v, head)
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    let r =
+                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+pub fn action(input: &Value, span: Span) -> Value {
+    if let Ok(value_span) = input.span() {
+        match input {
+            Value::Filesize { .. } => input.clone(),
+            Value::Int { val, .. } => Value::Filesize {
+                val: *val,
+                span: value_span,
+            },
+            Value::Float { val, .. } => Value::Filesize {
+                val: *val as i64,
+                span: value_span,
+            },
+            Value::String { val, .. } => match int_from_string(val, value_span) {
+                Ok(val) => Value::Filesize {
+                    val,
+                    span: value_span,
+                },
+                Err(error) => Value::Error { error },
+            },
+            _ => Value::Error {
+                error: ShellError::UnsupportedInput(
+                    "'into filesize' for unsupported type".into(),
+                    value_span,
+                ),
+            },
+        }
+    } else {
+        Value::Error {
+            error: ShellError::UnsupportedInput(
+                "'into filesize' for unsupported type".into(),
+                span,
+            ),
+        }
+    }
+}
+fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {
+    match a_string.trim().parse::<bytesize::ByteSize>() {
+        Ok(n) => Ok(n.0 as i64),
+        Err(_) => Err(ShellError::CantConvert("int".into(), "string".into(), span)),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

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

@@ -0,0 +1,302 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
+};
+
+struct Arguments {
+    radix: Option<Value>,
+    column_paths: Vec<CellPath>,
+}
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "into int"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into int")
+            .named("radix", SyntaxShape::Number, "radix of integer", Some('r'))
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "column paths to convert to int (for table input)",
+            )
+            .category(Category::Conversions)
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to integer"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        into_int(engine_state, stack, call, input)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to integer in table",
+                example: "echo [[num]; ['-5'] [4] [1.5]] | into int num",
+                result: None,
+            },
+            Example {
+                description: "Convert string to integer",
+                example: "'2' | into int",
+                result: Some(Value::test_int(2)),
+            },
+            Example {
+                description: "Convert decimal to integer",
+                example: "5.9 | into int",
+                result: Some(Value::test_int(5)),
+            },
+            Example {
+                description: "Convert decimal string to integer",
+                example: "'5.9' | into int",
+                result: Some(Value::test_int(5)),
+            },
+            Example {
+                description: "Convert file size to integer",
+                example: "4KB | into int",
+                result: Some(Value::Int {
+                    val: 4000,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Convert bool to integer",
+                example: "[false, true] | into int",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(0), Value::test_int(1)],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Convert to integer from binary",
+                example: "'1101' | into int -r 2",
+                result: Some(Value::test_int(13)),
+            },
+            Example {
+                description: "Convert to integer from hex",
+                example: "'FF' |  into int -r 16",
+                result: Some(Value::test_int(255)),
+            },
+        ]
+    }
+}
+
+fn into_int(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+    let head = call.head;
+
+    let options = Arguments {
+        radix: call.get_flag(engine_state, stack, "radix")?,
+        column_paths: call.rest(engine_state, stack, 0)?,
+    };
+
+    let radix: u32 = match options.radix {
+        Some(Value::Int { val, .. }) => val as u32,
+        Some(_) => 10,
+        None => 10,
+    };
+
+    if let Some(val) = &options.radix {
+        if !(2..=36).contains(&radix) {
+            return Err(ShellError::UnsupportedInput(
+                "Radix must lie in the range [2, 36]".to_string(),
+                val.span()?,
+            ));
+        }
+    }
+
+    input.map(
+        move |v| {
+            if options.column_paths.is_empty() {
+                action(&v, head, radix)
+            } else {
+                let mut ret = v;
+                for path in &options.column_paths {
+                    let r = ret.update_cell_path(
+                        &path.members,
+                        Box::new(move |old| action(old, head, radix)),
+                    );
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+pub fn action(input: &Value, span: Span, radix: u32) -> Value {
+    match input {
+        Value::Int { val: _, .. } => {
+            if radix == 10 {
+                input.clone()
+            } else {
+                convert_int(input, span, radix)
+            }
+        }
+        Value::Filesize { val, .. } => Value::Int { val: *val, span },
+        Value::Float { val, .. } => Value::Int {
+            val: *val as i64,
+            span,
+        },
+        Value::String { val, .. } => {
+            if radix == 10 {
+                match int_from_string(val, span) {
+                    Ok(val) => Value::Int { val, span },
+                    Err(error) => Value::Error { error },
+                }
+            } else {
+                convert_int(input, span, radix)
+            }
+        }
+        Value::Bool { val, .. } => {
+            if *val {
+                Value::Int { val: 1, span }
+            } else {
+                Value::Int { val: 0, span }
+            }
+        }
+        _ => Value::Error {
+            error: ShellError::UnsupportedInput("'into int' for unsupported type".into(), span),
+        },
+    }
+}
+
+fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
+    let i = match input {
+        Value::Int { val, .. } => val.to_string(),
+        Value::String { val, .. } => {
+            if val.starts_with("0x") || val.starts_with("0b") {
+                match int_from_string(val, head) {
+                    Ok(x) => return Value::Int { val: x, span: head },
+                    Err(e) => return Value::Error { error: e },
+                }
+            }
+            val.to_string()
+        }
+        _ => {
+            return Value::Error {
+                error: ShellError::UnsupportedInput(
+                    "only strings or integers are supported".to_string(),
+                    head,
+                ),
+            }
+        }
+    };
+    match i64::from_str_radix(&i, radix) {
+        Ok(n) => Value::Int { val: n, span: head },
+        Err(reason) => Value::Error {
+            error: ShellError::CantConvert("".to_string(), reason.to_string(), head),
+        },
+    }
+}
+
+fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {
+    let trimmed = a_string.trim();
+    match trimmed {
+        b if b.starts_with("0b") => {
+            let num = match i64::from_str_radix(b.trim_start_matches("0b"), 2) {
+                Ok(n) => n,
+                Err(reason) => {
+                    return Err(ShellError::CantConvert(
+                        "could not parse as integer".to_string(),
+                        reason.to_string(),
+                        span,
+                    ))
+                }
+            };
+            Ok(num)
+        }
+        h if h.starts_with("0x") => {
+            let num = match i64::from_str_radix(h.trim_start_matches("0x"), 16) {
+                Ok(n) => n,
+                Err(reason) => {
+                    return Err(ShellError::CantConvert(
+                        "could not parse as int".to_string(),
+                        reason.to_string(),
+                        span,
+                    ))
+                }
+            };
+            Ok(num)
+        }
+        _ => match a_string.parse::<i64>() {
+            Ok(n) => Ok(n),
+            Err(_) => match a_string.parse::<f64>() {
+                Ok(f) => Ok(f as i64),
+                _ => Err(ShellError::CantConvert(
+                    "into int".to_string(),
+                    "string".to_string(),
+                    span,
+                )),
+            },
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Value;
+    use super::*;
+    use nu_protocol::Type::Error;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+
+    #[test]
+    fn turns_to_integer() {
+        let word = Value::test_string("10");
+        let expected = Value::test_int(10);
+
+        let actual = action(&word, Span::test_data(), 10);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn turns_binary_to_integer() {
+        let s = Value::test_string("0b101");
+        let actual = action(&s, Span::test_data(), 10);
+        assert_eq!(actual, Value::test_int(5));
+    }
+
+    #[test]
+    fn turns_hex_to_integer() {
+        let s = Value::test_string("0xFF");
+        let actual = action(&s, Span::test_data(), 16);
+        assert_eq!(actual, Value::test_int(255));
+    }
+
+    #[test]
+    fn communicates_parsing_error_given_an_invalid_integerlike_string() {
+        let integer_str = Value::test_string("36anra");
+
+        let actual = action(&integer_str, Span::test_data(), 10);
+
+        assert_eq!(actual.get_type(), Error)
+    }
+}

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

@@ -0,0 +1,19 @@
+mod binary;
+mod bool;
+mod command;
+mod datetime;
+mod decimal;
+mod duration;
+mod filesize;
+mod int;
+mod string;
+
+pub use self::bool::SubCommand as IntoBool;
+pub use self::filesize::SubCommand as IntoFilesize;
+pub use binary::SubCommand as IntoBinary;
+pub use command::Into;
+pub use datetime::SubCommand as IntoDatetime;
+pub use decimal::SubCommand as IntoDecimal;
+pub use duration::SubCommand as IntoDuration;
+pub use int::SubCommand as IntoInt;
+pub use string::SubCommand as IntoString;

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

@@ -0,0 +1,292 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Category, Config, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span,
+    SyntaxShape, Value,
+};
+
+// TODO num_format::SystemLocale once platform-specific dependencies are stable (see Cargo.toml)
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "into string"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into string")
+            // FIXME - need to support column paths
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "column paths to convert to string (for table input)",
+            )
+            .named(
+                "decimals",
+                SyntaxShape::Int,
+                "decimal digits to which to round",
+                Some('d'),
+            )
+            .category(Category::Conversions)
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to string"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        string_helper(engine_state, stack, call, input)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "convert decimal to string and round to nearest integer",
+                example: "1.7 | into string -d 0",
+                result: Some(Value::String {
+                    val: "2".to_string(),
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "convert decimal to string",
+                example: "1.7 | into string -d 1",
+                result: Some(Value::String {
+                    val: "1.7".to_string(),
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "convert decimal to string and limit to 2 decimals",
+                example: "1.734 | into string -d 2",
+                result: Some(Value::String {
+                    val: "1.73".to_string(),
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "try to convert decimal to string and provide negative decimal points",
+                example: "1.734 | into string -d -2",
+                result: None,
+                // FIXME
+                // result: Some(Value::Error {
+                //     error: ShellError::UnsupportedInput(
+                //         String::from("Cannot accept negative integers for decimals arguments"),
+                //         Span::test_data(),
+                //     ),
+                // }),
+            },
+            Example {
+                description: "convert decimal to string",
+                example: "4.3 | into string",
+                result: Some(Value::String {
+                    val: "4.3".to_string(),
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "convert string to string",
+                example: "'1234' | into string",
+                result: Some(Value::String {
+                    val: "1234".to_string(),
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "convert boolean to string",
+                example: "true | into string",
+                result: Some(Value::String {
+                    val: "true".to_string(),
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "convert date to string",
+                example: "date now | into string",
+                result: None,
+            },
+            Example {
+                description: "convert filepath to string",
+                example: "ls Cargo.toml | get name | into string",
+                result: None,
+            },
+            Example {
+                description: "convert filesize to string",
+                example: "ls Cargo.toml | get size | into string",
+                result: None,
+            },
+        ]
+    }
+}
+
+fn string_helper(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<nu_protocol::PipelineData, ShellError> {
+    let decimals = call.has_flag("decimals");
+    let head = call.head;
+    let decimals_value: Option<i64> = call.get_flag(engine_state, stack, "decimals")?;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+    let config = stack.get_config().unwrap_or_default();
+
+    if let Some(decimal_val) = decimals_value {
+        if decimals && decimal_val.is_negative() {
+            return Err(ShellError::UnsupportedInput(
+                "Cannot accept negative integers for decimals arguments".to_string(),
+                head,
+            ));
+        }
+    }
+
+    match input {
+        PipelineData::ExternalStream { stdout: None, .. } => Ok(Value::String {
+            val: String::new(),
+            span: head,
+        }
+        .into_pipeline_data()),
+        PipelineData::ExternalStream {
+            stdout: Some(stream),
+            ..
+        } => {
+            // TODO: in the future, we may want this to stream out, converting each to bytes
+            let output = stream.into_string()?;
+            Ok(Value::String {
+                val: output.item,
+                span: head,
+            }
+            .into_pipeline_data())
+        }
+        _ => input.map(
+            move |v| {
+                if column_paths.is_empty() {
+                    action(&v, head, decimals, decimals_value, false, &config)
+                } else {
+                    let mut ret = v;
+                    for path in &column_paths {
+                        let config = config.clone();
+                        let r = ret.update_cell_path(
+                            &path.members,
+                            Box::new(move |old| {
+                                action(old, head, decimals, decimals_value, false, &config)
+                            }),
+                        );
+                        if let Err(error) = r {
+                            return Value::Error { error };
+                        }
+                    }
+
+                    ret
+                }
+            },
+            engine_state.ctrlc.clone(),
+        ),
+    }
+}
+
+pub fn action(
+    input: &Value,
+    span: Span,
+    decimals: bool,
+    digits: Option<i64>,
+    group_digits: bool,
+    config: &Config,
+) -> Value {
+    match input {
+        Value::Int { val, .. } => {
+            let res = if group_digits {
+                format_int(*val) // int.to_formatted_string(*locale)
+            } else {
+                val.to_string()
+            };
+
+            Value::String { val: res, span }
+        }
+        Value::Float { val, .. } => {
+            if decimals {
+                let decimal_value = digits.unwrap_or(2) as usize;
+                Value::String {
+                    val: format!("{:.*}", decimal_value, val),
+                    span,
+                }
+            } else {
+                Value::String {
+                    val: val.to_string(),
+                    span,
+                }
+            }
+        }
+        Value::Bool { val, .. } => Value::String {
+            val: val.to_string(),
+            span,
+        },
+        Value::Date { val, .. } => Value::String {
+            val: val.format("%c").to_string(),
+            span,
+        },
+        Value::String { val, .. } => Value::String {
+            val: val.to_string(),
+            span,
+        },
+
+        Value::Filesize { val: _, .. } => Value::String {
+            val: input.into_string(", ", config),
+            span,
+        },
+        Value::Nothing { .. } => Value::String {
+            val: "nothing".to_string(),
+            span,
+        },
+        Value::Record {
+            cols: _,
+            vals: _,
+            span: _,
+        } => Value::Error {
+            error: ShellError::UnsupportedInput(
+                "Cannot convert Record into string".to_string(),
+                span,
+            ),
+        },
+        x => Value::Error {
+            error: ShellError::CantConvert(String::from("string"), x.get_type().to_string(), span),
+        },
+    }
+}
+fn format_int(int: i64) -> String {
+    int.to_string()
+
+    // TODO once platform-specific dependencies are stable (see Cargo.toml)
+    // #[cfg(windows)]
+    // {
+    //     int.to_formatted_string(&Locale::en)
+    // }
+    // #[cfg(not(windows))]
+    // {
+    //     match SystemLocale::default() {
+    //         Ok(locale) => int.to_formatted_string(&locale),
+    //         Err(_) => int.to_formatted_string(&Locale::en),
+    //     }
+    // }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

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

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

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

@@ -0,0 +1,45 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape};
+
+#[derive(Clone)]
+pub struct Alias;
+
+impl Command for Alias {
+    fn name(&self) -> &str {
+        "alias"
+    }
+
+    fn usage(&self) -> &str {
+        "Alias a command (with optional flags) to a new name"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("alias")
+            .required("name", SyntaxShape::String, "name of the alias")
+            .required(
+                "initial_value",
+                SyntaxShape::Keyword(b"=".to_vec(), Box::new(SyntaxShape::Expression)),
+                "equals sign followed by value",
+            )
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(PipelineData::new(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Alias ll to ls -l",
+            example: "alias ll = ls -l",
+            result: None,
+        }]
+    }
+}

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

@@ -0,0 +1,85 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Span, Value};
+
+#[derive(Clone)]
+pub struct Debug;
+
+impl Command for Debug {
+    fn name(&self) -> &str {
+        "debug"
+    }
+
+    fn usage(&self) -> &str {
+        "Debug print the value(s) piped in."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("debug").category(Category::Core).switch(
+            "raw",
+            "Prints the raw value representation",
+            Some('r'),
+        )
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        let config = stack.get_config().unwrap_or_default();
+        let raw = call.has_flag("raw");
+
+        input.map(
+            move |x| {
+                if raw {
+                    Value::String {
+                        val: x.debug_value(),
+                        span: head,
+                    }
+                } else {
+                    Value::String {
+                        val: x.debug_string(", ", &config),
+                        span: head,
+                    }
+                }
+            },
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Print the value of a string",
+                example: "'hello' | debug",
+                result: Some(Value::test_string("hello")),
+            },
+            Example {
+                description: "Print the value of a table",
+                example: "echo [[version patch]; [0.1.0 false] [0.1.1 true] [0.2.0 false]] | debug",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::test_string("{version: 0.1.0, patch: false}"),
+                        Value::test_string("{version: 0.1.1, patch: true}"),
+                        Value::test_string("{version: 0.2.0, patch: false}"),
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_examples() {
+        use super::Debug;
+        use crate::test_examples;
+        test_examples(Debug {})
+    }
+}

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

@@ -0,0 +1,53 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Value};
+
+#[derive(Clone)]
+pub struct Def;
+
+impl Command for Def {
+    fn name(&self) -> &str {
+        "def"
+    }
+
+    fn usage(&self) -> &str {
+        "Define a custom command"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("def")
+            .required("def_name", SyntaxShape::String, "definition name")
+            .required("params", SyntaxShape::Signature, "parameters")
+            .required(
+                "block",
+                SyntaxShape::Block(Some(vec![])),
+                "body of the definition",
+            )
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(PipelineData::new(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Define a command and run it",
+                example: r#"def say-hi [] { echo 'hi' }; say-hi"#,
+                result: Some(Value::test_string("hi")),
+            },
+            Example {
+                description: "Define a command and run it with parameter(s)",
+                example: r#"def say-sth [sth: string] { echo $sth }; say-sth hi"#,
+                result: Some(Value::test_string("hi")),
+            },
+        ]
+    }
+}

crates/nu-command/src/core_commands/def_env.rs

@@ -0,0 +1,49 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Value};
+
+#[derive(Clone)]
+pub struct DefEnv;
+
+impl Command for DefEnv {
+    fn name(&self) -> &str {
+        "def-env"
+    }
+
+    fn usage(&self) -> &str {
+        "Define a custom command, which participates in the caller environment"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("def-env")
+            .required("def_name", SyntaxShape::String, "definition name")
+            .required("params", SyntaxShape::Signature, "parameters")
+            .required(
+                "block",
+                SyntaxShape::Block(Some(vec![])),
+                "body of the definition",
+            )
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(PipelineData::new(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Set environment variable by call a custom command",
+            example: r#"def-env foo [] { let-env BAR = "BAZ" }; foo; $env.BAR"#,
+            result: Some(Value::String {
+                val: "BAZ".to_string(),
+                span: Span::test_data(),
+            }),
+        }]
+    }
+}

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

@@ -0,0 +1,63 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Value,
+};
+
+#[derive(Clone)]
+pub struct Describe;
+
+impl Command for Describe {
+    fn name(&self) -> &str {
+        "describe"
+    }
+
+    fn usage(&self) -> &str {
+        "Describe the value(s) piped in."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("describe").category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        if matches!(input, PipelineData::ExternalStream { .. }) {
+            Ok(PipelineData::Value(
+                Value::string("raw input", call.head),
+                None,
+            ))
+        } else {
+            let value = input.into_value(call.head);
+            Ok(Value::String {
+                val: value.get_type().to_string(),
+                span: head,
+            }
+            .into_pipeline_data())
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Describe the type of a string",
+            example: "'hello' | describe",
+            result: Some(Value::test_string("string")),
+        }]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_examples() {
+        use super::Describe;
+        use crate::test_examples;
+        test_examples(Describe {})
+    }
+}

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

@@ -0,0 +1,130 @@
+use nu_engine::{eval_block, CallExt};
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{CaptureBlock, Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Value};
+
+#[derive(Clone)]
+pub struct Do;
+
+impl Command for Do {
+    fn name(&self) -> &str {
+        "do"
+    }
+
+    fn usage(&self) -> &str {
+        "Run a block"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("do")
+            .desc(self.usage())
+            .required("block", SyntaxShape::Any, "the block to run")
+            .switch(
+                "ignore-errors",
+                "ignore errors as the block runs",
+                Some('i'),
+            )
+            .rest("rest", SyntaxShape::Any, "the parameter(s) for the block")
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let block: CaptureBlock = call.req(engine_state, stack, 0)?;
+        let rest: Vec<Value> = call.rest(engine_state, stack, 1)?;
+        let ignore_errors = call.has_flag("ignore-errors");
+
+        let mut stack = stack.captures_to_stack(&block.captures);
+        let block = engine_state.get_block(block.block_id);
+
+        let params: Vec<_> = block
+            .signature
+            .required_positional
+            .iter()
+            .chain(block.signature.optional_positional.iter())
+            .collect();
+
+        for param in params.iter().zip(&rest) {
+            if let Some(var_id) = param.0.var_id {
+                stack.add_var(var_id, param.1.clone())
+            }
+        }
+
+        if let Some(param) = &block.signature.rest_positional {
+            if rest.len() > params.len() {
+                let mut rest_items = vec![];
+
+                for r in rest.into_iter().skip(params.len()) {
+                    rest_items.push(r);
+                }
+
+                let span = if let Some(rest_item) = rest_items.first() {
+                    rest_item.span()?
+                } else {
+                    call.head
+                };
+
+                stack.add_var(
+                    param
+                        .var_id
+                        .expect("Internal error: rest positional parameter lacks var_id"),
+                    Value::List {
+                        vals: rest_items,
+                        span,
+                    },
+                )
+            }
+        }
+        let result = eval_block(
+            engine_state,
+            &mut stack,
+            block,
+            input,
+            call.redirect_stdout,
+            ignore_errors,
+        );
+
+        if ignore_errors {
+            match result {
+                Ok(x) => Ok(x),
+                Err(_) => Ok(PipelineData::new(call.head)),
+            }
+        } else {
+            result
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Run the block",
+                example: r#"do { echo hello }"#,
+                result: Some(Value::test_string("hello")),
+            },
+            Example {
+                description: "Run the block and ignore errors",
+                example: r#"do -i { thisisnotarealcommand }"#,
+                result: None,
+            },
+            Example {
+                description: "Run the block, with a positional parameter",
+                example: r#"do {|x| 100 + $x } 50"#,
+                result: Some(Value::test_int(150)),
+            },
+        ]
+    }
+}
+
+mod test {
+    #[test]
+    fn test_examples() {
+        use super::Do;
+        use crate::test_examples;
+        test_examples(Do {})
+    }
+}

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

@@ -0,0 +1,81 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, ListStream, PipelineData, ShellError, Signature, SyntaxShape, Value,
+};
+
+#[derive(Clone)]
+pub struct Echo;
+
+impl Command for Echo {
+    fn name(&self) -> &str {
+        "echo"
+    }
+
+    fn usage(&self) -> &str {
+        "Echo the arguments back to the user."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("echo")
+            .rest("rest", SyntaxShape::Any, "the values to echo")
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        call.rest(engine_state, stack, 0).map(|to_be_echoed| {
+            let n = to_be_echoed.len();
+            match n.cmp(&1usize) {
+                //  More than one value is converted in a stream of values
+                std::cmp::Ordering::Greater => PipelineData::ListStream(
+                    ListStream::from_stream(to_be_echoed.into_iter(), engine_state.ctrlc.clone()),
+                    None,
+                ),
+
+                //  But a single value can be forwarded as it is
+                std::cmp::Ordering::Equal => PipelineData::Value(to_be_echoed[0].clone(), None),
+
+                //  When there are no elements, we echo the empty string
+                std::cmp::Ordering::Less => PipelineData::Value(
+                    Value::String {
+                        val: "".to_string(),
+                        span: call.head,
+                    },
+                    None,
+                ),
+            }
+        })
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Put a hello message in the pipeline",
+                example: "echo 'hello'",
+                result: Some(Value::test_string("hello")),
+            },
+            Example {
+                description: "Print the value of the special '$nu' variable",
+                example: "echo $nu",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_examples() {
+        use super::Echo;
+        use crate::test_examples;
+        test_examples(Echo {})
+    }
+}

crates/nu-command/src/core_commands/error_make.rs

@@ -0,0 +1,125 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Value,
+};
+
+#[derive(Clone)]
+pub struct ErrorMake;
+
+impl Command for ErrorMake {
+    fn name(&self) -> &str {
+        "error make"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("error make")
+            .optional("error_struct", SyntaxShape::Record, "the error to create")
+            .category(Category::Core)
+    }
+
+    fn usage(&self) -> &str {
+        "Create an error."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let span = call.head;
+        let ctrlc = engine_state.ctrlc.clone();
+        let arg: Option<Value> = call.opt(engine_state, stack, 0)?;
+
+        if let Some(arg) = arg {
+            Ok(make_error(&arg)
+                .map(|err| Value::Error { error: err })
+                .unwrap_or_else(|| Value::Error {
+                    error: ShellError::SpannedLabeledError(
+                        "Creating error value not supported.".into(),
+                        "unsupported error format".into(),
+                        span,
+                    ),
+                })
+                .into_pipeline_data())
+        } else {
+            input.map(
+                move |value| {
+                    make_error(&value)
+                        .map(|err| Value::Error { error: err })
+                        .unwrap_or_else(|| Value::Error {
+                            error: ShellError::SpannedLabeledError(
+                                "Creating error value not supported.".into(),
+                                "unsupported error format".into(),
+                                span,
+                            ),
+                        })
+                },
+                ctrlc,
+            )
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Create a custom error for a custom command",
+                example: r#"def foo [x] {
+      let span = (metadata $x).span;
+      error make {msg: "this is fishy", label: {text: "fish right here", start: $span.start, end: $span.end } }
+    }"#,
+                result: None,
+            },
+            Example {
+                description: "Create a simple custom error for a custom command",
+                example: r#"def foo [x] {
+      error make {msg: "this is fishy"}
+    }"#,
+                result: None,
+            },
+        ]
+    }
+}
+
+fn make_error(value: &Value) -> Option<ShellError> {
+    if let Value::Record { .. } = &value {
+        let msg = value.get_data_by_key("msg");
+        let label = value.get_data_by_key("label");
+
+        match (msg, &label) {
+            (Some(Value::String { val: message, .. }), Some(label)) => {
+                let label_start = label.get_data_by_key("start");
+                let label_end = label.get_data_by_key("end");
+                let label_text = label.get_data_by_key("text");
+
+                match (label_start, label_end, label_text) {
+                    (
+                        Some(Value::Int { val: start, .. }),
+                        Some(Value::Int { val: end, .. }),
+                        Some(Value::String {
+                            val: label_text, ..
+                        }),
+                    ) => Some(ShellError::SpannedLabeledError(
+                        message,
+                        label_text,
+                        Span {
+                            start: start as usize,
+                            end: end as usize,
+                        },
+                    )),
+                    _ => None,
+                }
+            }
+            (Some(Value::String { val: message, .. }), None) => {
+                Some(ShellError::UnlabeledError(message))
+            }
+            _ => None,
+        }
+    } else {
+        None
+    }
+}

crates/nu-command/src/core_commands/export.rs

@@ -0,0 +1,53 @@
+use nu_engine::get_full_help;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, Example, IntoPipelineData, PipelineData, Signature, Span, Value,
+};
+
+#[derive(Clone)]
+pub struct ExportCommand;
+
+impl Command for ExportCommand {
+    fn name(&self) -> &str {
+        "export"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("export").category(Category::Core)
+    }
+
+    fn usage(&self) -> &str {
+        "Export custom commands or environment variables from a module."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(Value::String {
+            val: get_full_help(
+                &ExportCommand.signature(),
+                &ExportCommand.examples(),
+                engine_state,
+                stack,
+            ),
+            span: call.head,
+        }
+        .into_pipeline_data())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Export a definition from a module",
+            example: r#"module utils { export def my-command [] { "hello" } }; use utils my-command; my-command"#,
+            result: Some(Value::String {
+                val: "hello".to_string(),
+                span: Span::test_data(),
+            }),
+        }]
+    }
+}

crates/nu-command/src/core_commands/export_alias.rs

@@ -0,0 +1,45 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape};
+
+#[derive(Clone)]
+pub struct ExportAlias;
+
+impl Command for ExportAlias {
+    fn name(&self) -> &str {
+        "export alias"
+    }
+
+    fn usage(&self) -> &str {
+        "Define an alias and export it from a module"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("export def")
+            .required("name", SyntaxShape::String, "name of the alias")
+            .required(
+                "initial_value",
+                SyntaxShape::Keyword(b"=".to_vec(), Box::new(SyntaxShape::Expression)),
+                "equals sign followed by value",
+            )
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(PipelineData::new(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "export an alias of ll to ls -l, from a module",
+            example: "export alias ll = ls -l",
+            result: None,
+        }]
+    }
+}

crates/nu-command/src/core_commands/export_def.rs

@@ -0,0 +1,49 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Value};
+
+#[derive(Clone)]
+pub struct ExportDef;
+
+impl Command for ExportDef {
+    fn name(&self) -> &str {
+        "export def"
+    }
+
+    fn usage(&self) -> &str {
+        "Define a custom command and export it from a module"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("export def")
+            .required("name", SyntaxShape::String, "definition name")
+            .required("params", SyntaxShape::Signature, "parameters")
+            .required(
+                "block",
+                SyntaxShape::Block(Some(vec![])),
+                "body of the definition",
+            )
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(PipelineData::new(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Define a custom command in a module and call it",
+            example: r#"module spam { export def foo [] { "foo" } }; use spam foo; foo"#,
+            result: Some(Value::String {
+                val: "foo".to_string(),
+                span: Span::test_data(),
+            }),
+        }]
+    }
+}

crates/nu-command/src/core_commands/export_def_env.rs

@@ -0,0 +1,49 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Value};
+
+#[derive(Clone)]
+pub struct ExportDefEnv;
+
+impl Command for ExportDefEnv {
+    fn name(&self) -> &str {
+        "export def-env"
+    }
+
+    fn usage(&self) -> &str {
+        "Define a custom command that participates in the environment and export it from a module"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("export def-env")
+            .required("name", SyntaxShape::String, "definition name")
+            .required("params", SyntaxShape::Signature, "parameters")
+            .required(
+                "block",
+                SyntaxShape::Block(Some(vec![])),
+                "body of the definition",
+            )
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(PipelineData::new(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Define a custom command that participates in the environment in a module and call it",
+            example: r#"module foo { export def-env bar [] { let-env FOO_BAR = "BAZ" } }; use foo bar; bar; $env.FOO_BAR"#,
+            result: Some(Value::String {
+                val: "BAZ".to_string(),
+                span: Span::test_data(),
+            }),
+        }]
+    }
+}

crates/nu-command/src/core_commands/export_env.rs

@@ -0,0 +1,53 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Value};
+
+#[derive(Clone)]
+pub struct ExportEnv;
+
+impl Command for ExportEnv {
+    fn name(&self) -> &str {
+        "export env"
+    }
+
+    fn usage(&self) -> &str {
+        "Export a block from a module that will be evaluated as an environment variable when imported."
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("export env")
+            .required(
+                "name",
+                SyntaxShape::String,
+                "name of the environment variable",
+            )
+            .required(
+                "block",
+                SyntaxShape::Block(Some(vec![])),
+                "body of the environment variable definition",
+            )
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        //TODO: Add the env to stack
+        Ok(PipelineData::new(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Import and evaluate environment variable from a module",
+            example: r#"module foo { export env FOO_ENV { "BAZ" } }; use foo FOO_ENV; $env.FOO_ENV"#,
+            result: Some(Value::String {
+                val: "BAZ".to_string(),
+                span: Span::test_data(),
+            }),
+        }]
+    }
+}

crates/nu-command/src/core_commands/export_extern.rs

@@ -0,0 +1,41 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape};
+
+#[derive(Clone)]
+pub struct ExportExtern;
+
+impl Command for ExportExtern {
+    fn name(&self) -> &str {
+        "export extern"
+    }
+
+    fn usage(&self) -> &str {
+        "Define an extern and export it from a module"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("export extern")
+            .required("def_name", SyntaxShape::String, "definition name")
+            .required("params", SyntaxShape::Signature, "parameters")
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(PipelineData::new(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Export the signature for an external command",
+            example: r#"export extern echo [text: string]"#,
+            result: None,
+        }]
+    }
+}