Update release.yml

# Description

_(Thank you for improving Nushell. Please, check our [contributing
guide](../CONTRIBUTING.md) and talk to the core team before making major
changes.)_

_(Description of your pull request goes here. **Provide examples and/or
screenshots** if your changes affect the user experience.)_

# User-Facing Changes

_(List of all changes that impact the user experience here. This helps
us keep track of breaking changes.)_

# Tests + Formatting

Don't forget to add tests that cover your changes.

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 --workspace -- -D warnings -D clippy::unwrap_used -A
clippy::needless_collect` to check that you're using the standard code
style
- `cargo test --workspace` to check that all tests pass

# After Submitting

If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.

.cargo/config.toml

@@ -1,6 +1,7 @@
-# increase the default windows stack size
 [target.x86_64-pc-windows-msvc]
-rustflags = ["-C", "link-args=-stack:10000000"]
+# increase the default windows stack size
+# statically link the CRT so users don't have to install it
+rustflags = ["-C", "link-args=-stack:10000000", "-C", "target-feature=+crt-static"]
 
 # keeping this but commentting out in case we need them in the future
 
@@ -11,3 +12,17 @@ rustflags = ["-C", "link-args=-stack:10000000"]
 # set a 2 gb stack size (0x80000000 = 2147483648 bytes = 2 GB)
 # [target.x86_64-apple-darwin]
 # rustflags = ["-C", "link-args=-Wl,-stack_size,0x80000000"]
+
+# How to use mold in linux and mac
+
+# [target.x86_64-unknown-linux-gnu]
+# linker = "clang"
+# rustflags = ["-C", "link-arg=-fuse-ld=/usr/local/bin/mold"]
+
+# [target.x86_64-apple-darwin]
+# linker = "clang"
+# rustflags = ["-C", "link-arg=-fuse-ld=mold"]
+
+# [target.aarch64-apple-darwin]
+# linker = "clang"
+# rustflags = ["-C", "link-arg=-fuse-ld=mold"]

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -53,7 +53,7 @@ body:
         | 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
+      required: true
   - type: textarea
     id: context
     attributes:

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,5 +1,6 @@
 name: Feature Request
 description: "When you want a new feature for something that doesn't already exist"
+labels: "enhancement"
 body:
   - type: textarea
     id: problem

.github/ISSUE_TEMPLATE/question.yml

@@ -0,0 +1,21 @@
+name: Question
+description: "When you have a question to ask"
+labels: "question"
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: Question
+      description: Leave your question here
+      placeholder: |
+        A clear and concise question
+        Example: Is there any equivalent of bash's $CDPATH in Nu?
+    validations:
+      required: true
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context and details
+      description: Add any other context, screenshots or other media that will help us understand your question here, if needed.
+    validations:
+      required: false

.github/pull_request_template.md

@@ -1,11 +1,24 @@
+
 # Description
 
-(description of your pull request here)
+_(Thank you for improving Nushell. Please, check our [contributing guide](../CONTRIBUTING.md) and talk to the core team before making major changes.)_
 
-# Tests
+_(Description of your pull request goes here. **Provide examples and/or screenshots** if your changes affect the user experience.)_
+
+# User-Facing Changes
+
+_(List of all changes that impact the user experience here. This helps us keep track of breaking changes.)_
+
+# Tests + Formatting
+
+Don't forget to add tests that cover your changes.
 
 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
+- `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes)
+- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect` to check that you're using the standard code style
+- `cargo test --workspace` to check that all tests pass
+
+# After Submitting
+
+If your PR had any user-facing changes, update [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged, if necessary. This will help us keep the docs up to date.

.github/workflows/ci.yml

@@ -1,74 +1,85 @@
-on: [pull_request]
+on:
+  pull_request:
+  push: # Run CI on the main branch after every merge. This is important to fill the GitHub Actions cache in a way that pull requests can see it
+    branches:
+      - main
 
-name: Continuous integration
+name: continuous-integration
 
 jobs:
-  ci:
+  nu-fmt-clippy:
     strategy:
-      fail-fast: false
+      fail-fast: true
       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 }}
+    env:
+      NUSHELL_CARGO_TARGET: ci
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
-      - name: Setup Rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          override: true
-          components: rustfmt, clippy
+      - name: Setup Rust toolchain and cache
+        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
 
       - name: Rustfmt
-        uses: actions-rs/cargo@v1
+        uses: actions-rs/cargo@v1.0.1
         with:
           command: fmt
           args: --all -- --check
 
       - name: Clippy
-        uses: actions-rs/cargo@v1
+        uses: actions-rs/cargo@v1.0.1
         with:
           command: clippy
-          args: --all ${{ matrix.flags }} -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
+          args: --workspace --exclude nu_plugin_* -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
 
-      - name: Build Nushell
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: ${{ matrix.flags }}
+  nu-tests:
+    env:
+      NUSHELL_CARGO_TARGET: ci
+
+    strategy:
+      fail-fast: true
+      matrix:
+        platform: [windows-latest, macos-latest, ubuntu-latest]
+        style: [default, dataframe]
+        rust:
+          - stable
+        include:
+          - style: default
+            flags: ""
+          - style: dataframe
+            flags: "--features=dataframe"
+        exclude:
+          # only test dataframes on Ubuntu (the fastest platform)
+          - platform: windows-latest
+            style: dataframe
+          - platform: macos-latest
+            style: dataframe
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust toolchain and cache
+        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
 
       - name: Tests
-        uses: actions-rs/cargo@v1
+        uses: actions-rs/cargo@v1.0.1
         with:
           command: test
-          args: --all ${{ matrix.flags }}
-
+          args: --workspace --profile ci --exclude nu_plugin_* ${{ matrix.flags }}
 
   python-virtualenv:
+    env:
+      NUSHELL_CARGO_TARGET: ci
+
     strategy:
-      fail-fast: false
+      fail-fast: true
       matrix:
         platform: [ubuntu-latest, macos-latest, windows-latest]
         rust:
@@ -79,36 +90,61 @@ jobs:
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
-      - name: Setup Rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          override: true
-          components: rustfmt, clippy
+      - name: Setup Rust toolchain and cache
+        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
 
       - name: Install Nushell
-        uses: actions-rs/cargo@v1
+        uses: actions-rs/cargo@v1.0.1
         with:
           command: install
-          args: --path=. --no-default-features
+          args: --locked --path=. --profile ci --no-default-features
 
       - name: Setup Python
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v4
         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
+        run: git clone https://github.com/pypa/virtualenv.git
         shell: bash
 
       - name: Test Nushell in virtualenv
         run: cd virtualenv && tox -e ${{ matrix.py }} -- -k nushell
         shell: bash
+
+  # Build+test plugins on their own, without the rest of Nu. This helps with CI parallelization and
+  # also helps test that the plugins build without any feature unification shenanigans
+  plugins:
+    env:
+      NUSHELL_CARGO_TARGET: ci
+
+    strategy:
+      fail-fast: true
+      matrix:
+        platform: [windows-latest, macos-latest, ubuntu-latest]
+        rust:
+          - stable
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust toolchain and cache
+        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
+
+      - name: Clippy
+        uses: actions-rs/cargo@v1.0.1
+        with:
+          command: clippy
+          args: --package nu_plugin_* ${{ matrix.flags }} -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
+
+      - name: Tests
+        uses: actions-rs/cargo@v1.0.1
+        with:
+          command: test
+          args: --profile ci --package nu_plugin_*

.github/workflows/manual.yml

@@ -0,0 +1,41 @@
+# This is a basic workflow that is manually triggered
+# Don't run it unless you know what you are doing
+
+name: Manual Workflow for Winget Submission
+
+# Controls when the action will run. Workflow runs when manually triggered using the UI
+# or API.
+on:
+  workflow_dispatch:
+    # Inputs the workflow accepts.
+    inputs:
+      ver:
+        # Friendly description to be shown in the UI instead of 'ver'
+        description: 'The nushell version to release'
+        # Default value if no value is explicitly provided
+        default: '0.66.0'
+        # Input has to be provided for the workflow to run
+        required: true
+      uri:
+        # Friendly description to be shown in the UI instead of 'uri'
+        description: 'The nushell windows .msi package URI to publish'
+        # Default value if no value is explicitly provided
+        default: 'https://github.com/nushell/nushell/releases/download/0.66.0/nu-0.66.0-x86_64-pc-windows-msvc.msi'
+        # Input has to be provided for the workflow to run
+        required: true
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job
+  rls-winget-pkg:
+    name: Publish winget package manually
+    # The type of runner that the job will run on
+    runs-on: windows-latest
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+    # Runs commands using the runners shell
+    - name: Submit package to Windows Package Manager Community Repository Manually
+      run: |
+          iwr https://github.com/microsoft/winget-create/releases/download/v1.0.4.0/wingetcreate.exe -OutFile wingetcreate.exe
+          .\wingetcreate.exe update Nushell.Nushell -s -v ${{ github.event.inputs.ver }} -u ${{ github.event.inputs.uri }} -t ${{ secrets.NUSHELL_PAT }}

.github/workflows/release-pkg.nu

@@ -0,0 +1,161 @@
+#!/usr/bin/env nu
+
+# Created: 2022/05/26 19:05:20
+# Description:
+#   A script to do the github release task, need nushell to be installed.
+# REF:
+#   1. https://github.com/volks73/cargo-wix
+
+# The main binary file to be released
+let bin = 'nu'
+let os = $env.OS
+let target = $env.TARGET
+# Repo source dir like `/home/runner/work/nushell/nushell`
+let src = $env.GITHUB_WORKSPACE
+let flags = $env.TARGET_RUSTFLAGS
+let dist = $'($env.GITHUB_WORKSPACE)/output'
+let version = (open Cargo.toml | get package.version)
+
+# $env
+
+$'(char nl)Packaging ($bin) v($version) for ($target) in ($src)...'; hr-line -b
+if not ('Cargo.lock' | path exists) { cargo generate-lockfile }
+
+$'Start building ($bin)...'; hr-line
+
+# ----------------------------------------------------------------------------
+# Build for Ubuntu and macOS
+# ----------------------------------------------------------------------------
+if $os in ['ubuntu-latest', 'macos-latest'] {
+    if $os == 'ubuntu-latest' {
+        sudo apt-get install libxcb-composite0-dev -y
+    }
+    if $target == 'aarch64-unknown-linux-gnu' {
+        sudo apt-get install gcc-aarch64-linux-gnu -y
+        let-env CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER = 'aarch64-linux-gnu-gcc'
+        cargo-build-nu $flags
+    } else if $target == 'armv7-unknown-linux-gnueabihf' {
+        sudo apt-get install pkg-config gcc-arm-linux-gnueabihf -y
+        let-env CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER = 'arm-linux-gnueabihf-gcc'
+        cargo-build-nu $flags
+    } else {
+        # musl-tools to fix 'Failed to find tool. Is `musl-gcc` installed?'
+        # Actually just for x86_64-unknown-linux-musl target
+        if $os == 'ubuntu-latest' { sudo apt install musl-tools -y }
+        cargo-build-nu $flags
+    }
+}
+
+# ----------------------------------------------------------------------------
+# Build for Windows without static-link-openssl feature
+# ----------------------------------------------------------------------------
+if $os in ['windows-latest'] {
+    if ($flags | str trim | is-empty) {
+        cargo build --release --all --target $target
+    } else {
+        cargo build --release --all --target $target $flags
+    }
+}
+
+# ----------------------------------------------------------------------------
+# Prepare for the release archive
+# ----------------------------------------------------------------------------
+let suffix = if $os == 'windows-latest' { '.exe' }
+# nu, nu_plugin_* were all included
+let executable = $'target/($target)/release/($bin)*($suffix)'
+$'Current executable file: ($executable)'
+
+cd $src; mkdir $dist;
+rm -rf $'target/($target)/release/*.d' $'target/($target)/release/nu_pretty_hex*'
+$'(char nl)All executable files:'; hr-line
+ls -f $executable
+
+$'(char nl)Copying release files...'; hr-line
+cp -v README.release.txt $'($dist)/README.txt'
+[LICENSE $executable] | each {|it| cp -rv $it $dist } | flatten
+
+$'(char nl)Check binary release version detail:'; hr-line
+let ver = if $os == 'windows-latest' {
+    (do -i { ./output/nu.exe -c 'version' }) | str join
+} else {
+    (do -i { ./output/nu -c 'version' }) | str join
+}
+if ($ver | str trim | is-empty) {
+    $'(ansi r)Incompatible nu binary...(ansi reset)'
+} else { $ver }
+
+# ----------------------------------------------------------------------------
+# Create a release archive and send it to output for the following steps
+# ----------------------------------------------------------------------------
+cd $dist; $'(char nl)Creating release archive...'; hr-line
+if $os in ['ubuntu-latest', 'macos-latest'] {
+
+    let files = (ls | get name)
+    let dest = $'($bin)-($version)-($target)'
+    let archive = $'($dist)/($dest).tar.gz'
+
+    mkdir $dest
+    $files | each {|it| mv $it $dest } | ignore
+
+    $'(char nl)(ansi g)Archive contents:(ansi reset)'; hr-line; ls $dest
+
+    tar -czf $archive $dest
+    print $'archive: ---> ($archive)'; ls $archive
+    echo $'::set-output name=archive::($archive)'
+
+} else if $os == 'windows-latest' {
+
+    let releaseStem = $'($bin)-($version)-($target)'
+
+    $'(char nl)Download less related stuffs...'; hr-line
+    aria2c https://github.com/jftuga/less-Windows/releases/download/less-v608/less.exe -o less.exe
+    aria2c https://raw.githubusercontent.com/jftuga/less-Windows/master/LICENSE -o LICENSE-for-less.txt
+
+    # Create Windows msi release package
+    if (get-env _EXTRA_) == 'msi' {
+
+        let wixRelease = $'($src)/target/wix/($releaseStem).msi'
+        $'(char nl)Start creating Windows msi package...'
+        cd $src; hr-line
+        # Wix need the binaries be stored in target/release/
+        cp -r $'($dist)/*' target/release/
+        cargo install cargo-wix --version 0.3.3
+        cargo wix --no-build --nocapture --package nu --output $wixRelease
+        echo $'::set-output name=archive::($wixRelease)'
+
+    } else {
+
+        $'(char nl)(ansi g)Archive contents:(ansi reset)'; hr-line; ls
+        let archive = $'($dist)/($releaseStem).zip'
+        7z a $archive *
+        print $'archive: ---> ($archive)';
+        let pkg = (ls -f $archive | get name)
+        if not ($pkg | is-empty) {
+            echo $'::set-output name=archive::($pkg | get 0)'
+        }
+    }
+}
+
+def 'cargo-build-nu' [ options: string ] {
+    if ($options | str trim | is-empty) {
+        cargo build --release --all --target $target --features=static-link-openssl
+    } else {
+        cargo build --release --all --target $target --features=static-link-openssl $options
+    }
+}
+
+# Print a horizontal line marker
+def 'hr-line' [
+    --blank-line(-b): bool
+] {
+    print $'(ansi g)---------------------------------------------------------------------------->(ansi reset)'
+    if $blank_line { char nl }
+}
+
+# Get the specified env key's value or ''
+def 'get-env' [
+    key: string           # The key to get it's env value
+    default: string = ''  # The default value for an empty env
+] {
+    $env | get -i $key | default $default
+}

.github/workflows/release.yml

@@ -1,3 +1,7 @@
+#
+# REF:
+#   1. https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstrategymatrixinclude
+#
 name: Create Release Draft
 
 on:
@@ -5,439 +9,89 @@ on:
   push:
     tags: ["[0-9]+.[0-9]+.[0-9]+*"]
 
+defaults:
+  run:
+    shell: bash
+
 jobs:
-  linux:
-    name: Build Linux
-    runs-on: ubuntu-latest
+  all:
+    name: All
+
+    strategy:
+      matrix:
+        target:
+        - aarch64-apple-darwin
+        - x86_64-apple-darwin
+        - x86_64-pc-windows-msvc
+        - x86_64-unknown-linux-gnu
+        - x86_64-unknown-linux-musl
+        - aarch64-unknown-linux-gnu
+        - armv7-unknown-linux-gnueabihf
+        extra: ['bin']
+        include:
+        - target: aarch64-apple-darwin
+          os: macos-latest
+          target_rustflags: ''
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: ''
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: ''
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: ''
+        - target: x86_64-unknown-linux-gnu
+          os: ubuntu-latest
+          target_rustflags: ''
+        - target: x86_64-unknown-linux-musl
+          os: ubuntu-latest
+          target_rustflags: ''
+        - target: aarch64-unknown-linux-gnu
+          os: ubuntu-latest
+          target_rustflags: ''
+        - target: armv7-unknown-linux-gnueabihf
+          os: ubuntu-latest
+          target_rustflags: ''
+
+    runs-on: ${{matrix.os}}
+
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+    - uses: actions/checkout@v3.0.2
 
-      - name: Install libxcb
-        run: sudo apt-get install libxcb-composite0-dev
-
-      - name: Set up cargo
-        uses: actions-rs/toolchain@v1
+    - name: Install Rust Toolchain Components
+      uses: actions-rs/toolchain@v1.0.6
       with:
+        override: true
         profile: minimal
         toolchain: stable
-          override: true
+        target: ${{ matrix.target }}
 
-      - name: Build
-        uses: actions-rs/cargo@v1
+    - name: Setup Nushell
+      uses: hustcer/setup-nu@v2.1
       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
+        version: 0.69.1
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Release Nu Binary
+      id: nu
+      run: nu .github/workflows/release-pkg.nu
+      env:
+        OS: ${{ matrix.os }}
+        REF: ${{ github.ref }}
+        TARGET: ${{ matrix.target }}
+        _EXTRA_: ${{ matrix.extra }}
+        TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
+
+    # REF: https://github.com/marketplace/actions/gh-release
+    - name: Publish Archive
+      uses: softprops/action-gh-release@v0.1.13
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
       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
+        files: ${{ steps.nu.outputs.archive }}
       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/winget-submission.yml

@@ -13,7 +13,7 @@ jobs:
     steps:
       - name: Submit package to Windows Package Manager Community Repository
         run: |
-          iwr https://aka.ms/wingetcreate/latest -OutFile wingetcreate.exe
+          iwr https://github.com/microsoft/winget-create/releases/download/v1.0.4.0/wingetcreate.exe -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
+          $installerUrl = $github.release.assets | Where-Object -Property name -match 'windows-msvc.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

@@ -21,3 +21,21 @@ debian/nu/
 
 # VSCode's IDE items
 .vscode/*
+
+# Visual Studio Extension SourceGear Rust items
+VSWorkspaceSettings.json
+unstable_cargo_features.txt
+
+# Helix configuration folder
+.helix/*
+.helix
+
+# Coverage tools
+lcov.info
+tarpaulin-report.html
+
+# Visual Studio
+.vs/*
+*.rsproj
+*.rsproj.user
+*.sln

CONTRIBUTING.md

@@ -1,21 +1,29 @@
 # Contributing
 
-Welcome to nushell!
+Welcome to Nushell and thank you for considering contributing!
 
-*Note: for a more complete guide see [The nu contributor book](https://www.nushell.sh/contributor-book/)*
+## Review Process
 
-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.
+First of all, before diving into the code, if you want to create a new feature, change something significantly, and especially if the change is user-facing, it is a good practice to first get an approval from the core team before starting to work on it.
+This saves both your and our time if we realize the change needs to go another direction before spending time on it.
+So, please, reach out and tell us what you want to do.
+This will significantly increase the chance of your PR being accepted.
 
-[![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-->
+The review process can be summarized as follows:
+1. You want to make some change to Nushell that is more involved than simple bug-fixing.
+2. Go to [Discord](https://discordapp.com/invite/NtAbbGn) or a [GitHub issue](https://github.com/nushell/nushell/issues/new/choose) and chat with some core team members and/or other contributors about it.
+3. After getting a green light from the core team, implement the feature, open a pull request (PR) and write a concise but comprehensive description of the change.
+4. If your PR includes any use-facing features (such as adding a flag to a command), clearly list them in the PR description.
+5. Then, core team members and other regular contributors will review the PR and suggest changes.
+6. When we all agree, the PR will be merged.
+7. If your PR includes any user-facing features, make sure the changes are also reflected in [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged.
+8. Congratulate yourself, you just improved Nushell! :-)
 
 ## Developing
 
-### Set up
+### Setup
 
-This is no different than other Rust projects.
+Nushell requires a recent Rust toolchain and some dependencies; [refer to the Nu Book for up-to-date requirements](https://www.nushell.sh/book/installation.html#build-from-source). After installing dependencies, you should be able to clone+build Nu like any other Rust project:
 
 ```bash
 git clone https://github.com/nushell/nushell
@@ -23,29 +31,41 @@ cd nushell
 cargo build
 ```
 
+### Tests
+
+It is a good practice to cover your changes with a test. Also, try to think about corner cases and various ways how your changes could break. Cover those in the tests as well.
+
+Tests can be found in different places:
+* `/tests`
+* `src/tests`
+* command examples
+* crate-specific tests
+
+The most comprehensive test suite we have is the `nu-test-support` crate. For testing specific features, such as running Nushell in a REPL mode, we have so called "testbins". For simple tests, you can find `run_test()` and `fail_test()` functions.
+
 ### Useful Commands
 
 - Build and run Nushell:
 
   ```shell
-  cargo build --release && cargo run --release
+  cargo run
   ```
 
-- Build and run with extra features:
+- Build and run with dataframe support.
   ```shell
-  cargo build --release --features=extra && cargo run --release --features=extra
+  cargo run --features=dataframe
   ```
 
 - Run Clippy on Nushell:
 
   ```shell
-  cargo clippy --all --features=stable
+  cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
   ```
 
 - Run all tests:
 
   ```shell
-  cargo test --all --features=stable
+  cargo test --workspace
   ```
 
 - Run all tests for a specific command
@@ -71,5 +91,11 @@ cargo build
 - To view verbose logs when developing, enable the `trace` log level.
 
   ```shell
-  cargo build --release --features=extra && cargo run --release --features=extra -- --log-level trace
+  cargo run --release -- --log-level trace
+  ```
+
+- To redirect trace logs to a file, enable the `--log-target file` switch.
+  ```shell
+  cargo run --release -- --log-level trace --log-target file
+  open $"($nu.temp-path)/nu-($nu.pid).log"
   ```

Cargo.toml

@@ -8,13 +8,19 @@ exclude = ["images"]
 homepage = "https://www.nushell.sh"
 license = "MIT"
 name = "nu"
-readme = "README.md"
 repository = "https://github.com/nushell/nushell"
-rust-version = "1.59"
-version = "0.61.0"
+rust-version = "1.60"
+version = "0.72.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[package.metadata.binstall]
+pkg-url = "{ repo }/releases/download/{ version }/{ name }-{ version }-{ target }.{ archive-format }"
+pkg-fmt = "tgz"
+
+[package.metadata.binstall.overrides.x86_64-pc-windows-msvc]
+pkg-fmt = "zip"
+
 [workspace]
 members = [
 	"crates/nu-cli",
@@ -28,57 +34,74 @@ members = [
 	"crates/nu_plugin_gstat",
 	"crates/nu_plugin_example",
 	"crates/nu_plugin_query",
+	"crates/nu_plugin_custom_values",
 	"crates/nu-utils",
 ]
 
 [dependencies]
-chrono = "0.4.19"
-crossterm = "0.23.0"
+chrono = { version = "0.4.23", features = ["serde"] }
+crossterm = "0.24.0"
 ctrlc = "3.2.1"
 log = "0.4"
-miette = "4.1.0"
-nu-ansi-term = "0.45.1"
-nu-cli = { path="./crates/nu-cli", version = "0.61.0"  }
-nu-color-config = { path = "./crates/nu-color-config", version = "0.61.0"  }
-nu-command = { path="./crates/nu-command", version = "0.61.0"  }
-nu-engine = { path="./crates/nu-engine", version = "0.61.0"  }
-nu-json = { path="./crates/nu-json", version = "0.61.0"  }
-nu-parser = { path="./crates/nu-parser", version = "0.61.0"  }
-nu-path = { path="./crates/nu-path", version = "0.61.0"  }
-nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.61.0"  }
-nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.61.0"  }
-nu-protocol = { path = "./crates/nu-protocol", version = "0.61.0"  }
-nu-system = { path = "./crates/nu-system", version = "0.61.0" }
-nu-table = { path = "./crates/nu-table", version = "0.61.0"  }
-nu-term-grid = { path = "./crates/nu-term-grid", version = "0.61.0"  }
-pretty_env_logger = "0.4.0"
+miette = { version = "5.1.0", features = ["fancy-no-backtrace"] }
+nu-ansi-term = "0.46.0"
+nu-cli = { path="./crates/nu-cli", version = "0.72.0"  }
+nu-color-config = { path = "./crates/nu-color-config", version = "0.72.0"  }
+nu-command = { path="./crates/nu-command", version = "0.72.0"  }
+nu-engine = { path="./crates/nu-engine", version = "0.72.0"  }
+nu-json = { path="./crates/nu-json", version = "0.72.0"  }
+nu-parser = { path="./crates/nu-parser", version = "0.72.0"  }
+nu-path = { path="./crates/nu-path", version = "0.72.0"  }
+nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.72.0"  }
+nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.72.0"  }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.72.0"  }
+nu-system = { path = "./crates/nu-system", version = "0.72.0" }
+nu-table = { path = "./crates/nu-table", version = "0.72.0"  }
+nu-term-grid = { path = "./crates/nu-term-grid", version = "0.72.0"  }
+nu-utils = { path = "./crates/nu-utils", version = "0.72.0"  }
+reedline = { version = "0.14.0", features = ["bashisms", "sqlite"]}
+
 rayon = "1.5.1"
-reedline = { version = "0.4.0", features = ["bashisms"]}
 is_executable = "1.0.1"
+simplelog = "0.12.0"
+time = "0.3.12"
+
+[target.'cfg(not(target_os = "windows"))'.dependencies]
+# Our dependencies don't use OpenSSL on Windows
+openssl = { version = "0.10.38", features = ["vendored"], optional = true }
+signal-hook = { version = "0.3.14", default-features = false }
+
+
+[target.'cfg(windows)'.build-dependencies]
+winres = "0.1"
+
+[target.'cfg(target_family = "unix")'.dependencies]
+nix = { version = "0.25", default-features = false, features = ["signal", "process", "fs", "term"]}
+atty = "0.2"
 
 [dev-dependencies]
-nu-test-support = { path="./crates/nu-test-support", version = "0.61.0"  }
+nu-test-support = { path="./crates/nu-test-support", version = "0.72.0"  }
 tempfile = "3.2.0"
 assert_cmd = "2.0.2"
 pretty_assertions = "1.0.0"
-serial_test = "0.5.1"
+serial_test = "0.8.0"
 hamcrest2 = "0.3.0"
-rstest = "0.12.0"
+rstest = {version = "0.15.0", default-features = false}
 itertools = "0.10.3"
 
-[target.'cfg(windows)'.build-dependencies]
-embed-resource = "1"
-
 [features]
 plugin = ["nu-plugin", "nu-cli/plugin", "nu-parser/plugin", "nu-command/plugin", "nu-protocol/plugin", "nu-engine/plugin"]
-default = ["plugin", "which-support", "zip-support", "trash-support"]
+# extra used to be more useful but now it's the same as default. Leaving it in for backcompat with existing build scripts
+extra = ["default"]
+default = ["plugin", "which-support", "trash-support", "sqlite"]
 stable = ["default"]
-extra = ["default", "dataframe"]
 wasi = []
 
+# Enable to statically link OpenSSL; otherwise the system version will be used. Not enabled by default because it takes a while to build
+static-link-openssl = ["dep:openssl"]
+
 # Stable (Default)
 which-support = ["nu-command/which-support"]
-zip-support = ["nu-command/zip"]
 trash-support = ["nu-command/trash-support"]
 
 # Extra
@@ -86,6 +109,9 @@ trash-support = ["nu-command/trash-support"]
 # Dataframe feature for nushell
 dataframe = ["nu-command/dataframe"]
 
+# SQLite commands for nushell
+sqlite = ["nu-command/sqlite"]
+
 [profile.release]
 opt-level = "s" # Optimize for size
 strip = "debuginfo"
@@ -98,7 +124,19 @@ inherits = "release"
 strip = false
 debug = true
 
+# build with `cargo build --profile ci`
+# to analyze performance with tooling like linux perf
+[profile.ci]
+inherits = "dev"
+strip = false
+debug = false
+
 # Main nu binary
 [[bin]]
 name = "nu"
 path = "src/main.rs"
+
+# To use a development version of a dependency please use a global override here
+# changing versions in each sub-crate of the workspace is tedious
+[patch.crates-io]
+# reedline = { git = "https://github.com/nushell/reedline.git", branch = "main" }

Makefile.toml

@@ -1,24 +0,0 @@
-[tasks.lalrpop]
-install_crate = { crate_name = "lalrpop", binary = "lalrpop", test_arg = "--help" }
-command = "lalrpop"
-args = ["src/parser/parser.lalrpop"]
-
-[tasks.baseline]
-command = "cargo"
-args = ["build", "--bins"]
-
-[tasks.run]
-command = "cargo"
-args = ["run"]
-dependencies = ["baseline"]
-
-[tasks.test]
-command = "cargo"
-args = ["test"]
-dependencies = ["baseline"]
-
-[tasks.check]
-command = "cargo"
-args = ["check"]
-dependencies = ["baseline"]
-

README.build.txt

@@ -1 +0,0 @@
-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,135 +1,106 @@
-# README
-
+# Nushell <!-- omit in toc -->
 [![Crates.io](https://img.shields.io/crates/v/nu.svg)](https://crates.io/crates/nu)
-[![Build Status](https://github.com/nushell/nushell/actions/workflows/ci.yml/badge.svg)](https://github.com/nushell/nushell/actions)
+![Build Status](https://img.shields.io/github/workflow/status/nushell/nushell/continuous-integration)
 [![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
-
 A new type of shell.
 
 ![Example of nushell](images/nushell-autocomplete6.gif "Example of nushell")
 
+## Table of Contents <!-- omit in toc -->
+
+- [Status](#status)
+- [Learning About Nu](#learning-about-nu)
+- [Installation](#installation)
+- [Philosophy](#philosophy)
+  - [Pipelines](#pipelines)
+  - [Opening files](#opening-files)
+  - [Plugins](#plugins)
+- [Goals](#goals)
+- [Progress](#progress)
+- [Officially Supported By](#officially-supported-by)
+- [Contributing](#contributing)
+- [License](#license)
+
 ## 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. Many people use it as their daily driver, but it may be unstable for some commands. Nu's design is 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.
+## Learning About Nu
 
-## Learning more
+The [Nushell book](https://www.nushell.sh/book/) is the primary source of Nushell documentation. You can find [a full list of Nu commands in the book](https://www.nushell.sh/book/command_reference.html), and we have many examples of using Nu in our [cookbook](https://www.nushell.sh/cookbook/).
 
-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.
-
-We also have an active [Discord](https://discord.gg/NtAbbGn) and [Twitter](https://twitter.com/nu_shell) if you'd like to come and chat with us.
-
-You can also find information on more specific topics in our [cookbook](https://www.nushell.sh/cookbook/).
+We're also active on [Discord](https://discord.gg/NtAbbGn) and [Twitter](https://twitter.com/nu_shell); come and chat with us!
 
 ## Installation
 
-### Local
+To quickly install Nu:
 
-Up-to-date installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/installation.html). **Windows users**: please note that Nu works on Windows 10 and does not currently have Windows 7/8.1 support.
-
-To build Nu, you will need to use the **latest stable (1.59 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`
-
-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 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
-```
-
-To install Nu via the [Windows Package Manager](https://aka.ms/winget-cli):
-
-```shell
+```bash
+# Linux and macOS
+brew install nushell
+# Windows
 winget install nushell
 ```
 
-To install Nu via the [Chocolatey](https://chocolatey.org) package manager:
+To use `Nu` in Github Action, check [setup-nu](https://github.com/marketplace/actions/setup-nu) for more detail.
 
-```shell
-choco install nushell
-```
-
-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:
-
-```shell
-cargo build --workspace --features=extra
-```
-### Packaging status
+Detailed installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/installation.html). Nu is available via many package managers:
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/nushell.svg)](https://repology.org/project/nushell/versions)
 
-#### Fedora
 
-[COPR repo](https://copr.fedorainfracloud.org/coprs/atim/nushell/): `sudo dnf copr enable atim/nushell -y && sudo dnf install nushell -y`
 
 ## 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.
+Rather than thinking of files and data 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
 
 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.
+As in 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 (e.g., `ls`)
--   Commands that filter a stream (eg, `where type == "Dir"`)
--   Commands that consume the output of the pipeline (e.g., `autoview`)
+-   Commands that filter a stream (e.g., `where type == "dir"`)
+-   Commands that consume the output of the pipeline (e.g., `table`)
 
 Commands are separated by the pipe symbol (`|`) to denote a pipeline flowing left to right.
 
 ```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
-───┴────────┴──────┴───────┴──────────────
+> ls | where type == "dir" | table
+╭────┬──────────┬──────┬─────────┬───────────────╮
+│ #  │   name   │ type │  size   │   modified    │
+├────┼──────────┼──────┼─────────┼───────────────┤
+│  0 │ .cargo   │ dir  │     0 B │ 9 minutes ago │
+│  1 │ assets   │ dir  │     0 B │ 2 weeks ago   │
+│  2 │ crates   │ dir  │ 4.0 KiB │ 2 weeks ago   │
+│  3 │ docker   │ dir  │     0 B │ 2 weeks ago   │
+│  4 │ docs     │ dir  │     0 B │ 2 weeks ago   │
+│  5 │ images   │ dir  │     0 B │ 2 weeks ago   │
+│  6 │ pkg_mgrs │ dir  │     0 B │ 2 weeks ago   │
+│  7 │ samples  │ dir  │     0 B │ 2 weeks ago   │
+│  8 │ src      │ dir  │ 4.0 KiB │ 2 weeks ago   │
+│  9 │ target   │ dir  │     0 B │ a day ago     │
+│ 10 │ tests    │ dir  │ 4.0 KiB │ 2 weeks ago   │
+│ 11 │ wix      │ dir  │     0 B │ 2 weeks ago   │
+╰────┴──────────┴──────┴─────────┴───────────────╯
 ```
 
-Because most of the time you'll want to see the output of a pipeline, `autoview` is assumed.
+Because most of the time you'll want to see the output of a pipeline, `table` is assumed.
 We could have also written the above:
 
 ```shell
-> ls | where type == Dir
+> ls | where type == "dir"
 ```
 
 Being able to use the same commands and compose them differently is an important philosophy in Nu.
@@ -137,15 +108,13 @@ For example, we could use the built-in `ps` command to get a list of the running
 
 ```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
-───┴────────┴───────────────────┴──────────┴─────────┴──────────┴──────────
+╭───┬───────┬───────────┬───────┬───────────┬───────────╮
+│ # │  pid  │   name    │  cpu  │    mem    │  virtual  │
+├───┼───────┼───────────┼───────┼───────────┼───────────┤
+│ 0 │  2240 │ Slack.exe │ 16.40 │ 178.3 MiB │ 232.6 MiB │
+│ 1 │ 16948 │ Slack.exe │ 16.32 │ 205.0 MiB │ 197.9 MiB │
+│ 2 │ 17700 │ nu.exe    │  3.77 │  26.1 MiB │   8.8 MiB │
+╰───┴───────┴───────────┴───────┴───────────┴───────────╯
 ```
 
 ### Opening files
@@ -155,72 +124,49 @@ For example, you can load a .toml file as structured data and explore it:
 
 ```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]
-────────────────────┴───────────────────────────
+╭──────────────────┬────────────────────╮
+│ bin              │ [table 1 row]      │
+│ dependencies     │ {record 24 fields} │
+│ dev-dependencies │ {record 8 fields}  │
+│ features         │ {record 10 fields} │
+│ package          │ {record 13 fields} │
+│ profile          │ {record 3 fields}  │
+│ target           │ {record 2 fields}  │
+│ workspace        │ {record 1 field}   │
+╰──────────────────┴────────────────────╯
 ```
 
-We can pipeline this into a command that gets the contents of one of the columns:
+We can pipe this into a command that gets the contents of one of the columns:
 
 ```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
-───────────────┴────────────────────────────────────
+╭───────────────┬────────────────────────────────────╮
+│ authors       │ [list 1 item]                      │
+│ default-run   │ nu                                 │
+│ description   │ A new type of shell                │
+│ documentation │ https://www.nushell.sh/book/       │
+│ edition       │ 2018                               │
+│ exclude       │ [list 1 item]                      │
+│ homepage      │ https://www.nushell.sh             │
+│ license       │ MIT                                │
+│ name          │ nu                                 │
+│ readme        │ README.md                          │
+│ repository    │ https://github.com/nushell/nushell │
+│ rust-version  │ 1.60                               │
+│ version       │ 0.63.1                             │
+╰───────────────┴────────────────────────────────────╯
 ```
 
-Finally, we can use commands outside of Nu once we have the data we want:
+And if needed we can drill down further:
 
 ```shell
 > open Cargo.toml | get package.version
-0.32.0
+0.63.1
 ```
 
-### 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).
-
-To set one of these variables, you can use `config set`. For example:
-
-```shell
-> config set line_editor.edit_mode "vi"
-> config set path $nu.path
-```
-
-### Shells
-
-Nu will work inside of a single directory and allow you to navigate around your filesystem by default.
-Nu also offers a way of adding additional working directories that you can jump between, allowing you to work in multiple directories simultaneously.
-
-To do so, use the `enter` command, which will allow you to create a new "shell" and enter it at the specified path.
-You can toggle between this new shell and the original shell with the `p` (for previous) and `n` (for next), allowing you to navigate around a ring buffer of shells.
-Once you're done with a shell, you can `exit` it and remove it from the ring buffer.
-
-Finally, to get a list of all the current shells, you can use the `shells` command.
-
 ### Plugins
 
-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.
+Nu supports plugins that offer additional functionality to the shell and follow the same structured data model that built-in commands use. There are a few examples in the `crates/nu_plugins_*` directories.
 
 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.
@@ -231,23 +177,19 @@ If the plugin is a sink, it is given the full vector of final data and is given
 
 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 consistent first-class support for Windows, macOS, and Linux.
+-   First and foremost, Nu is cross-platform. Commands and techniques should work across platforms and Nu has 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 compatibility with existing platform-specific executables.
 
--   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 expected of modern software in 2022 (and beyond).
 
--   Nu views data as both structured and unstructured. It is a structured shell like PowerShell.
+-   Nu views data as either structured or 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.
 
-## Commands
-
-You can find a list of Nu commands, complete with documentation, in [quick command references](https://www.nushell.sh/book/command_reference.html).
-
 ## Progress
 
-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:
+Nu is under heavy development and will naturally change as it matures. The chart below isn't meant to be exhaustive, but it helps give an idea for some of the areas of development and their relative maturity:
 
 | Features      | Not started | Prototype | MVP | Preview | Mature | Notes                                                                |
 | ------------- | :---------: | :-------: | :-: | :-----: | :----: | -------------------------------------------------------------------- |
@@ -264,28 +206,24 @@ Nu is in heavy development and will naturally change as it matures and people us
 | 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           |
+| Type-checking |             |           |     |    x    |        | Commands check basic types, and input/output types                   |
 
 ## Officially Supported By
 
 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)
 -   [oh-my-posh](https://ohmyposh.dev)
 -   [Couchbase Shell](https://couchbase.sh)
-###   Mentions
--   [The Python Launcher for Unix](https://github.com/brettcannon/python-launcher#how-do-i-get-a-table-of-python-executables-in-nushell)
+-   [virtualenv](https://github.com/pypa/virtualenv)
 
 ## Contributing
 
-See [Contributing](CONTRIBUTING.md) for details.
-
-Thanks to all the people who already contributed!
+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" />
+  <img src="https://contributors-img.web.app/image?repo=nushell/nushell&max=500" />
 </a>
 
 ## License

README.release.txt

@@ -0,0 +1,3 @@
+To use Nu plugins, use the register command to tell Nu where to find the plugin. For example:
+
+> register ./nu_plugin_query

assets/nushell.rc

@@ -1,49 +0,0 @@
-#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

@@ -1,7 +1,8 @@
-#!/bin/sh
+#!/usr/bin/env bash
+set -euo pipefail
 
 echo "---------------------------------------------------------------"
-echo "Building nushell (nu) with --features=extra and all the plugins"
+echo "Building nushell (nu) with dataframes and all the plugins"
 echo "---------------------------------------------------------------"
 echo ""
 
@@ -10,13 +11,14 @@ NU_PLUGINS=(
     'nu_plugin_gstat'
     'nu_plugin_inc'
     'nu_plugin_query'
+    'nu_plugin_custom_values'
 )
 
 echo "Building nushell"
-cargo build --features=extra
+cargo build --features=dataframe
 for plugin in "${NU_PLUGINS[@]}"
 do
-    echo '' && cd crates/$plugin
+    echo '' && cd crates/"$plugin"
     echo "Building $plugin..."
     echo "-----------------------------"
     cargo build && cd ../..

build-all-windows.cmd

@@ -1,11 +1,11 @@
 @echo off
 @echo -------------------------------------------------------------------
-@echo Building nushell (nu.exe) with --features=extra and all the plugins
+@echo Building nushell (nu.exe) with dataframes and all the plugins
 @echo -------------------------------------------------------------------
 @echo.
 
 echo Building nushell.exe
-cargo build --features=extra
+cargo build cargo build --features=dataframe
 @echo.
 
 @cd crates\nu_plugin_example
@@ -24,9 +24,13 @@ cargo build
 @echo.
 
 @cd ..\..\crates\nu_plugin_query
-
 echo Building nu_plugin_query.exe
 cargo build
 @echo.
 
+@cd ..\..\crates\nu_plugin_custom_values
+echo Building nu_plugin_custom_values.exe
+cargo build
+@echo.
+
 @cd ..\..

build-all.nu

@@ -1,16 +1,17 @@
 echo '-------------------------------------------------------------------'
-echo 'Building nushell (nu) with --features=extra and all the plugins'
+echo 'Building nushell (nu) with dataframes and all the plugins'
 echo '-------------------------------------------------------------------'
 
 echo $'(char nl)Building nushell'
 echo '----------------------------'
-cargo build --features=extra
+cargo build --features=dataframe
 
 let plugins = [
     nu_plugin_inc,
     nu_plugin_gstat,
     nu_plugin_query,
     nu_plugin_example,
+    nu_plugin_custom_values,
 ]
 
 for plugin in $plugins {

build.rs

@@ -1,6 +1,12 @@
 #[cfg(windows)]
 fn main() {
-    embed_resource::compile_for("assets/nushell.rc", &["nu"])
+    let mut res = winres::WindowsResource::new();
+    res.set("ProductName", "Nushell");
+    res.set("FileDescription", "Nushell");
+    res.set("LegalCopyright", "Copyright (C) 2022");
+    res.set_icon("assets/nu_logo.ico");
+    res.compile()
+        .expect("Failed to run the Windows resource compiler (rc.exe)");
 }
 
 #[cfg(not(windows))]

crates/nu-cli/Cargo.toml

@@ -1,27 +1,39 @@
 [package]
 authors = ["The Nushell Project Developers"]
 description = "CLI-related functionality for Nushell"
+repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cli"
 edition = "2021"
 license = "MIT"
 name = "nu-cli"
-version = "0.61.0"
+version = "0.72.0"
+
+[dev-dependencies]
+nu-test-support = { path="../nu-test-support", version = "0.72.0"  }
+nu-command = { path = "../nu-command", version = "0.72.0" }
+rstest = {version = "0.15.0", default-features = false}
 
 [dependencies]
-nu-engine = { path = "../nu-engine", version = "0.61.0"  }
-nu-path = { path = "../nu-path", version = "0.61.0"  }
-nu-parser = { path = "../nu-parser", version = "0.61.0"  }
-nu-protocol = { path = "../nu-protocol", version = "0.61.0"  }
-nu-utils = { path = "../nu-utils", version = "0.61.0"  }
-nu-ansi-term = "0.45.1"
-nu-color-config = { path = "../nu-color-config", version = "0.61.0"  }
+nu-engine = { path = "../nu-engine", version = "0.72.0"  }
+nu-path = { path = "../nu-path", version = "0.72.0"  }
+nu-parser = { path = "../nu-parser", version = "0.72.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.72.0"  }
+nu-utils = { path = "../nu-utils", version = "0.72.0"  }
+nu-ansi-term = "0.46.0"
+nu-color-config = { path = "../nu-color-config", version = "0.72.0"  }
+reedline = { version = "0.14.0", features = ["bashisms", "sqlite"]}
 
-crossterm = "0.23.0"
-miette = { version = "4.4.0", features = ["fancy"] }
-thiserror = "1.0.29"
-reedline = { version = "0.4.0", features = ["bashisms"]}
-
-log = "0.4"
+atty = "0.2.14"
+chrono = { default-features = false, features = ["std"], version = "0.4.23" }
+crossterm = "0.24.0"
+fancy-regex = "0.10.0"
+fuzzy-matcher = "0.3.7"
 is_executable = "1.0.1"
+lazy_static = "1.4.0"
+log = "0.4"
+miette = { version = "5.1.0", features = ["fancy-no-backtrace"] }
+percent-encoding = "2"
+sysinfo = "0.26.2"
+thiserror = "1.0.31"
 
 [features]
 plugin = []

crates/nu-cli/src/commands.rs

@@ -2,36 +2,39 @@ 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_parser::parse;
 use nu_protocol::engine::Stack;
 use nu_protocol::{
-    engine::{EngineState, StateDelta, StateWorkingSet},
-    Config, PipelineData, Spanned,
+    engine::{EngineState, StateWorkingSet},
+    PipelineData, Spanned, Value,
 };
-use std::path::Path;
 
+/// Run a command (or commands) given to us by the user
 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
+    table_mode: Option<Value>,
+) -> Result<Option<i64>> {
+    // 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);
+    }
+
+    // Parse the source code
     let (block, delta) = {
+        if let Some(ref t_mode) = table_mode {
+            let mut config = engine_state.get_config().clone();
+            config.table_mode = t_mode.as_string()?;
+            engine_state.set_config(&config);
+        }
+
         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, &[]);
+        let (output, err) = parse(&mut working_set, None, commands.item.as_bytes(), false, &[]);
         if let Some(err) = err {
             report_error(&working_set, &err);
 
@@ -41,47 +44,20 @@ pub fn evaluate_commands(
         (output, working_set.render())
     };
 
-    if let Err(err) = engine_state.merge_delta(delta, None, init_cwd) {
+    // Update permanent state
+    if let Err(err) = engine_state.merge_delta(delta) {
         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()
-        }
-    };
-
-    // 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) {
+    // Run the block
+    let exit_code = 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)
+            let mut config = engine_state.get_config().clone();
+            if let Some(t_mode) = table_mode {
+                config.table_mode = t_mode.as_string()?;
+            }
+            crate::eval_file::print_table_or_error(engine_state, stack, pipeline_data, &mut config)
         }
         Err(err) => {
             let working_set = StateWorkingSet::new(engine_state);
@@ -89,11 +65,9 @@ pub fn evaluate_commands(
             report_error(&working_set, &err);
             std::process::exit(1);
         }
-    }
+    };
 
-    if is_perf_true {
     info!("evaluate {}:{}:{}", file!(), line!(), column!());
-    }
 
-    Ok(())
+    Ok(exit_code)
 }

crates/nu-cli/src/completions/base.rs

@@ -12,50 +12,19 @@ pub trait Completer {
         span: Span,
         offset: usize,
         pos: usize,
-    ) -> (Vec<Suggestion>, CompletionOptions);
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion>;
 
-    // Filter results using the completion options
-    fn filter(
-        &self,
-        prefix: Vec<u8>,
-        items: Vec<Suggestion>,
-        options: CompletionOptions,
-    ) -> Vec<Suggestion> {
-        items
-            .into_iter()
-            .filter(|it| {
-                // Minimise clones for new functionality
-                match (options.case_sensitive, options.positional) {
-                    (true, true) => it.value.as_bytes().starts_with(&prefix),
-                    (true, false) => it
-                        .value
-                        .contains(std::str::from_utf8(&prefix).unwrap_or("")),
-                    (false, positional) => {
-                        let value = it.value.to_lowercase();
-                        let prefix = std::str::from_utf8(&prefix).unwrap_or("").to_lowercase();
-                        if positional {
-                            value.starts_with(&prefix)
-                        } else {
-                            value.contains(&prefix)
-                        }
-                    }
-                }
-            })
-            .collect()
+    fn get_sort_by(&self) -> SortBy {
+        SortBy::Ascending
     }
 
-    // Sort results using the completion options
-    fn sort(
-        &self,
-        items: Vec<Suggestion>,
-        prefix: Vec<u8>,
-        options: CompletionOptions,
-    ) -> Vec<Suggestion> {
+    fn sort(&self, items: Vec<Suggestion>, prefix: Vec<u8>) -> Vec<Suggestion> {
         let prefix_str = String::from_utf8_lossy(&prefix).to_string();
         let mut filtered_items = items;
 
         // Sort items
-        match options.sort_by {
+        match self.get_sort_by() {
             SortBy::LevenshteinDistance => {
                 filtered_items.sort_by(|a, b| {
                     let a_distance = levenshtein_distance(&prefix_str, &a.value);

crates/nu-cli/src/completions/command_completions.rs

@@ -1,7 +1,5 @@
-use crate::completions::{
-    file_completions::file_path_completion, Completer, CompletionOptions, SortBy,
-};
-use nu_parser::{trim_quotes, FlatShape};
+use crate::completions::{Completer, CompletionOptions, MatchAlgorithm, SortBy};
+use nu_parser::FlatShape;
 use nu_protocol::{
     engine::{EngineState, StateWorkingSet},
     Span,
@@ -12,8 +10,8 @@ use std::sync::Arc;
 pub struct CommandCompletion {
     engine_state: Arc<EngineState>,
     flattened: Vec<(Span, FlatShape)>,
-    flat_idx: usize,
     flat_shape: FlatShape,
+    force_completion_after_space: bool,
 }
 
 impl CommandCompletion {
@@ -21,21 +19,25 @@ impl CommandCompletion {
         engine_state: Arc<EngineState>,
         _: &StateWorkingSet,
         flattened: Vec<(Span, FlatShape)>,
-        flat_idx: usize,
         flat_shape: FlatShape,
+        force_completion_after_space: bool,
     ) -> Self {
         Self {
             engine_state,
             flattened,
-            flat_idx,
             flat_shape,
+            force_completion_after_space,
         }
     }
 
-    fn external_command_completion(&self, prefix: &str) -> Vec<String> {
+    fn external_command_completion(
+        &self,
+        prefix: &str,
+        match_algorithm: MatchAlgorithm,
+    ) -> Vec<String> {
         let mut executables = vec![];
 
-        let paths = self.engine_state.env_vars.get("PATH");
+        let paths = self.engine_state.get_env_var("PATH");
 
         if let Some(paths) = paths {
             if let Ok(paths) = paths.as_list() {
@@ -44,18 +46,21 @@ impl CommandCompletion {
 
                     if let Ok(mut contents) = std::fs::read_dir(path) {
                         while let Some(Ok(item)) = contents.next() {
-                            if !executables.contains(
+                            if self.engine_state.config.max_external_completion_results
+                                > executables.len() as i64
+                                && !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)),
+                                )
+                                && matches!(
+                                    item.path().file_name().map(|x| match_algorithm
+                                        .matches_str(&x.to_string_lossy(), prefix)),
                                     Some(true)
-                            ) && is_executable::is_executable(&item.path())
+                                )
+                                && is_executable::is_executable(item.path())
                             {
                                 if let Ok(name) = item.file_name().into_string() {
                                     executables.push(name);
@@ -76,11 +81,14 @@ impl CommandCompletion {
         span: Span,
         offset: usize,
         find_externals: bool,
+        match_algorithm: MatchAlgorithm,
     ) -> Vec<Suggestion> {
-        let prefix = working_set.get_span_contents(span);
+        let partial = working_set.get_span_contents(span);
+
+        let filter_predicate = |command: &[u8]| match_algorithm.matches_u8(command, partial);
 
         let results = working_set
-            .find_commands_by_prefix(prefix)
+            .find_commands_by_predicate(filter_predicate)
             .into_iter()
             .map(move |x| Suggestion {
                 value: String::from_utf8_lossy(&x.0).to_string(),
@@ -90,11 +98,11 @@ impl CommandCompletion {
                     start: span.start - offset,
                     end: span.end - offset,
                 },
+                append_whitespace: true,
             });
 
-        let results_aliases =
-            working_set
-                .find_aliases_by_prefix(prefix)
+        let results_aliases = working_set
+            .find_aliases_by_predicate(filter_predicate)
             .into_iter()
             .map(move |x| Suggestion {
                 value: String::from_utf8_lossy(&x).to_string(),
@@ -104,15 +112,17 @@ impl CommandCompletion {
                     start: span.start - offset,
                     end: span.end - offset,
                 },
+                append_whitespace: true,
             });
 
         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();
-        let results = if find_externals {
-            let results_external =
-                self.external_command_completion(&prefix)
+        let partial = working_set.get_span_contents(span);
+        let partial = String::from_utf8_lossy(partial).to_string();
+
+        if find_externals {
+            let results_external = self
+                .external_command_completion(&partial, match_algorithm)
                 .into_iter()
                 .map(move |x| Suggestion {
                     value: x,
@@ -122,6 +132,7 @@ impl CommandCompletion {
                         start: span.start - offset,
                         end: span.end - offset,
                     },
+                    append_whitespace: true,
                 });
 
             for external in results_external {
@@ -131,6 +142,7 @@ impl CommandCompletion {
                         description: None,
                         extra: None,
                         span: external.span,
+                        append_whitespace: true,
                     })
                 } else {
                     results.push(external)
@@ -140,9 +152,7 @@ impl CommandCompletion {
             results
         } else {
             results
-        };
-
-        results
+        }
     }
 }
 
@@ -150,11 +160,12 @@ impl Completer for CommandCompletion {
     fn fetch(
         &mut self,
         working_set: &StateWorkingSet,
-        prefix: Vec<u8>,
+        _prefix: Vec<u8>,
         span: Span,
         offset: usize,
         pos: usize,
-    ) -> (Vec<Suggestion>, CompletionOptions) {
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
         let last = self
             .flattened
             .iter()
@@ -172,9 +183,6 @@ impl Completer for CommandCompletion {
             })
             .last();
 
-        // Options
-        let options = CompletionOptions::new(true, true, SortBy::LevenshteinDistance);
-
         // 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(
@@ -185,90 +193,44 @@ impl Completer for CommandCompletion {
                 },
                 offset,
                 false,
+                options.match_algorithm,
             )
         } else {
             vec![]
         };
 
         if !subcommands.is_empty() {
-            return (subcommands, options);
+            return subcommands;
         }
 
+        let config = working_set.get_config();
         let commands = if matches!(self.flat_shape, nu_parser::FlatShape::External)
             || matches!(self.flat_shape, nu_parser::FlatShape::InternalCall)
             || ((span.end - span.start) == 0)
         {
             // we're in a gap or at a command
-            self.complete_commands(working_set, 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(),
+            if working_set.get_span_contents(span).is_empty() && !self.force_completion_after_space
+            {
+                return vec![];
             }
-        } else {
-            "".to_string()
-        };
-
-        let preceding_byte = if span.start > offset {
-            working_set
-                .get_span_contents(Span {
-                    start: span.start - 1,
-                    end: span.start,
-                })
-                .to_vec()
+            self.complete_commands(
+                working_set,
+                span,
+                offset,
+                config.enable_external_completion,
+                options.match_algorithm,
+            )
         } else {
             vec![]
         };
-        // let prefix = working_set.get_span_contents(flat.0);
-        let prefix = String::from_utf8_lossy(&prefix).to_string();
-        let output = file_path_completion(span, &prefix, &cwd)
+
+        subcommands
             .into_iter()
-            .map(move |x| {
-                if self.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| Suggestion {
-                value: x.1,
-                description: None,
-                extra: None,
-                span: reedline::Span {
-                    start: x.0.start - offset,
-                    end: x.0.end - offset,
-                },
-            })
-            .chain(subcommands.into_iter())
             .chain(commands.into_iter())
-            .collect::<Vec<_>>();
-
-        (output, options)
+            .collect::<Vec<_>>()
     }
 
-    // Replace base filter with no filter once all the results are already based in the current path
-    fn filter(&self, _: Vec<u8>, items: Vec<Suggestion>, _: CompletionOptions) -> Vec<Suggestion> {
-        items
+    fn get_sort_by(&self) -> SortBy {
+        SortBy::LevenshteinDistance
     }
 }

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

@@ -1,28 +1,29 @@
 use crate::completions::{
-    CommandCompletion, Completer, CustomCompletion, FileCompletion, FlagCompletion,
-    VariableCompletion,
+    CommandCompletion, Completer, CompletionOptions, CustomCompletion, DirectoryCompletion,
+    DotNuCompletion, FileCompletion, FlagCompletion, MatchAlgorithm, VariableCompletion,
 };
+use nu_engine::eval_block;
 use nu_parser::{flatten_expression, parse, FlatShape};
 use nu_protocol::{
+    ast::PipelineElement,
     engine::{EngineState, Stack, StateWorkingSet},
-    Span, Value,
+    BlockId, PipelineData, Span, Value,
 };
 use reedline::{Completer as ReedlineCompleter, Suggestion};
+use std::str;
 use std::sync::Arc;
 
 #[derive(Clone)]
 pub struct NuCompleter {
     engine_state: Arc<EngineState>,
     stack: Stack,
-    config: Option<Value>,
 }
 
 impl NuCompleter {
-    pub fn new(engine_state: Arc<EngineState>, stack: Stack, config: Option<Value>) -> Self {
+    pub fn new(engine_state: Arc<EngineState>, stack: Stack) -> Self {
         Self {
             engine_state,
             stack,
-            config,
         }
     }
 
@@ -36,52 +37,157 @@ impl NuCompleter {
         offset: usize,
         pos: usize,
     ) -> Vec<Suggestion> {
-        // Fetch
-        let (mut suggestions, options) =
-            completer.fetch(working_set, prefix.clone(), new_span, offset, pos);
+        let config = self.engine_state.get_config();
 
-        // Filter
-        suggestions = completer.filter(prefix.clone(), suggestions, options.clone());
+        let mut options = CompletionOptions {
+            case_sensitive: config.case_sensitive_completions,
+            ..Default::default()
+        };
+
+        if config.completion_algorithm == "fuzzy" {
+            options.match_algorithm = MatchAlgorithm::Fuzzy;
+        }
+
+        // Fetch
+        let mut suggestions =
+            completer.fetch(working_set, prefix.clone(), new_span, offset, pos, &options);
 
         // Sort
-        suggestions = completer.sort(suggestions, prefix, options);
+        suggestions = completer.sort(suggestions, prefix);
 
         suggestions
     }
 
+    fn external_completion(
+        &self,
+        block_id: BlockId,
+        spans: &[String],
+        offset: usize,
+        span: Span,
+    ) -> Option<Vec<Suggestion>> {
+        let stack = self.stack.clone();
+        let block = self.engine_state.get_block(block_id);
+        let mut callee_stack = stack.gather_captures(&block.captures);
+
+        // Line
+        if let Some(pos_arg) = block.signature.required_positional.get(0) {
+            if let Some(var_id) = pos_arg.var_id {
+                callee_stack.add_var(
+                    var_id,
+                    Value::List {
+                        vals: spans
+                            .iter()
+                            .map(|it| Value::String {
+                                val: it.to_string(),
+                                span: Span::unknown(),
+                            })
+                            .collect(),
+                        span: Span::unknown(),
+                    },
+                );
+            }
+        }
+
+        let result = eval_block(
+            &self.engine_state,
+            &mut callee_stack,
+            block,
+            PipelineData::new(span),
+            true,
+            true,
+        );
+
+        match result {
+            Ok(pd) => {
+                let value = pd.into_value(span);
+                if let Value::List { vals, span: _ } = value {
+                    let result = map_value_completions(
+                        vals.iter(),
+                        Span {
+                            start: span.start,
+                            end: span.end,
+                        },
+                        offset,
+                    );
+
+                    return Some(result);
+                }
+            }
+            Err(err) => println!("failed to eval completer block: {}", err),
+        }
+
+        None
+    }
+
     fn completion_helper(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
         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 (mut new_line, alias_offset) = try_find_alias(line.as_bytes(), &working_set);
+        let initial_line = line.to_string();
+        let alias_total_offset: usize = alias_offset.iter().sum();
+        new_line.insert(alias_total_offset + pos, b'a');
         let pos = offset + pos;
-        let (output, _err) = parse(
-            &mut working_set,
-            Some("completer"),
-            line.as_bytes(),
-            false,
-            &[],
-        );
+        let config = self.engine_state.get_config();
+
+        let (output, _err) = parse(&mut working_set, Some("completer"), &new_line, false, &[]);
 
         for pipeline in output.pipelines.into_iter() {
-            for expr in pipeline.expressions {
+            for pipeline_element in pipeline.elements {
+                match pipeline_element {
+                    PipelineElement::Expression(_, expr)
+                    | PipelineElement::Redirection(_, _, expr)
+                    | PipelineElement::And(_, expr)
+                    | PipelineElement::Or(_, expr) => {
                         let flattened: Vec<_> = flatten_expression(&working_set, &expr);
+                        let span_offset: usize = alias_offset.iter().sum();
+                        let mut spans: Vec<String> = vec![];
 
                         for (flat_idx, flat) in flattened.iter().enumerate() {
-                    if pos >= flat.0.start && pos < flat.0.end {
+                            // Read the current spam to string
+                            let current_span = working_set.get_span_contents(flat.0).to_vec();
+                            let current_span_str = String::from_utf8_lossy(&current_span);
+
+                            // Skip the last 'a' as span item
+                            if flat_idx == flattened.len() - 1 {
+                                let mut chars = current_span_str.chars();
+                                chars.next_back();
+                                let current_span_str = chars.as_str().to_owned();
+                                spans.push(current_span_str.to_string());
+                            } else {
+                                spans.push(current_span_str.to_string());
+                            }
+
+                            // Complete based on the last span
+                            if pos + span_offset >= flat.0.start && pos + span_offset < flat.0.end {
+                                // Context variables
+                                let most_left_var =
+                                    most_left_variable(flat_idx, &working_set, flattened.clone());
+
                                 // Create a new span
-                        let new_span = Span {
+                                let new_span = if flat_idx == 0 {
+                                    Span {
                                         start: flat.0.start,
-                            end: flat.0.end - 1,
+                                        end: flat.0.end - 1 - span_offset,
+                                    }
+                                } else {
+                                    Span {
+                                        start: flat.0.start - span_offset,
+                                        end: flat.0.end - 1 - span_offset,
+                                    }
                                 };
 
-                        // Parses the prefix
+                                // Parses the prefix. Completion should look up to the cursor position, not after.
                                 let mut prefix = working_set.get_span_contents(flat.0).to_vec();
-                        prefix.remove(pos - flat.0.start);
+                                let index = pos - (flat.0.start - span_offset);
+                                prefix.drain(index..);
 
                                 // Variables completion
-                        if prefix.starts_with(b"$") {
-                            let mut completer = VariableCompletion::new(self.engine_state.clone());
+                                if prefix.starts_with(b"$") || most_left_var.is_some() {
+                                    let mut completer = VariableCompletion::new(
+                                        self.engine_state.clone(),
+                                        self.stack.clone(),
+                                        most_left_var.unwrap_or((vec![], vec![])),
+                                    );
 
                                     return self.process_completion(
                                         &mut completer,
@@ -95,8 +201,44 @@ impl NuCompleter {
 
                                 // Flags completion
                                 if prefix.starts_with(b"-") {
-                            let mut completer = FlagCompletion::new(expr);
+                                    // Try to complete flag internally
+                                    let mut completer = FlagCompletion::new(expr.clone());
+                                    let result = self.process_completion(
+                                        &mut completer,
+                                        &working_set,
+                                        prefix.clone(),
+                                        new_span,
+                                        offset,
+                                        pos,
+                                    );
 
+                                    if !result.is_empty() {
+                                        return result;
+                                    }
+
+                                    // We got no results for internal completion
+                                    // now we can check if external completer is set and use it
+                                    if let Some(block_id) = config.external_completer {
+                                        if let Some(external_result) = self
+                                            .external_completion(block_id, &spans, offset, new_span)
+                                        {
+                                            return external_result;
+                                        }
+                                    }
+                                }
+
+                                // specially check if it is currently empty - always complete commands
+                                if flat_idx == 0
+                                    && working_set.get_span_contents(new_span).is_empty()
+                                {
+                                    let mut completer = CommandCompletion::new(
+                                        self.engine_state.clone(),
+                                        &working_set,
+                                        flattened.clone(),
+                                        // flat_idx,
+                                        FlatShape::String,
+                                        true,
+                                    );
                                     return self.process_completion(
                                         &mut completer,
                                         &working_set,
@@ -107,15 +249,51 @@ impl NuCompleter {
                                     );
                                 }
 
+                                // Completions that depends on the previous expression (e.g: use, source-env)
+                                if flat_idx > 0 {
+                                    if let Some(previous_expr) = flattened.get(flat_idx - 1) {
+                                        // Read the content for the previous expression
+                                        let prev_expr_str =
+                                            working_set.get_span_contents(previous_expr.0).to_vec();
+
+                                        // Completion for .nu files
+                                        if prev_expr_str == b"use" || prev_expr_str == b"source-env"
+                                        {
+                                            let mut completer =
+                                                DotNuCompletion::new(self.engine_state.clone());
+
+                                            return self.process_completion(
+                                                &mut completer,
+                                                &working_set,
+                                                prefix,
+                                                new_span,
+                                                offset,
+                                                pos,
+                                            );
+                                        } else if prev_expr_str == b"ls" {
+                                            let mut completer =
+                                                FileCompletion::new(self.engine_state.clone());
+
+                                            return self.process_completion(
+                                                &mut completer,
+                                                &working_set,
+                                                prefix,
+                                                new_span,
+                                                offset,
+                                                pos,
+                                            );
+                                        }
+                                    }
+                                }
+
                                 // Match other types
                                 match &flat.1 {
                                     FlatShape::Custom(decl_id) => {
                                         let mut completer = CustomCompletion::new(
                                             self.engine_state.clone(),
                                             self.stack.clone(),
-                                    self.config.clone(),
                                             *decl_id,
-                                    line,
+                                            initial_line,
                                         );
 
                                         return self.process_completion(
@@ -127,8 +305,22 @@ impl NuCompleter {
                                             pos,
                                         );
                                     }
+                                    FlatShape::Directory => {
+                                        let mut completer =
+                                            DirectoryCompletion::new(self.engine_state.clone());
+
+                                        return self.process_completion(
+                                            &mut completer,
+                                            &working_set,
+                                            prefix,
+                                            new_span,
+                                            offset,
+                                            pos,
+                                        );
+                                    }
                                     FlatShape::Filepath | FlatShape::GlobPattern => {
-                                let mut completer = FileCompletion::new(self.engine_state.clone());
+                                        let mut completer =
+                                            FileCompletion::new(self.engine_state.clone());
 
                                         return self.process_completion(
                                             &mut completer,
@@ -144,11 +336,37 @@ impl NuCompleter {
                                             self.engine_state.clone(),
                                             &working_set,
                                             flattened.clone(),
-                                    flat_idx,
+                                            // flat_idx,
                                             flat_shape.clone(),
+                                            false,
                                         );
 
-                                return self.process_completion(
+                                        let mut out: Vec<_> = self.process_completion(
+                                            &mut completer,
+                                            &working_set,
+                                            prefix.clone(),
+                                            new_span,
+                                            offset,
+                                            pos,
+                                        );
+
+                                        if !out.is_empty() {
+                                            return out;
+                                        }
+
+                                        // Try to complete using an external completer (if set)
+                                        if let Some(block_id) = config.external_completer {
+                                            if let Some(external_result) = self.external_completion(
+                                                block_id, &spans, offset, new_span,
+                                            ) {
+                                                return external_result;
+                                            }
+                                        }
+
+                                        // Check for file completion
+                                        let mut completer =
+                                            FileCompletion::new(self.engine_state.clone());
+                                        out = self.process_completion(
                                             &mut completer,
                                             &working_set,
                                             prefix,
@@ -156,14 +374,20 @@ impl NuCompleter {
                                             offset,
                                             pos,
                                         );
+
+                                        if !out.is_empty() {
+                                            return out;
+                                        }
                                     }
                                 };
                             }
                         }
                     }
                 }
+            }
+        }
 
-        return vec![];
+        vec![]
     }
 }
 
@@ -172,3 +396,194 @@ impl ReedlineCompleter for NuCompleter {
         self.completion_helper(line, pos)
     }
 }
+
+type MatchedAlias = Vec<(Vec<u8>, Vec<u8>)>;
+
+// Handler the completion when giving lines contains at least one alias. (e.g: `g checkout`)
+// that `g` is an alias of `git`
+fn try_find_alias(line: &[u8], working_set: &StateWorkingSet) -> (Vec<u8>, Vec<usize>) {
+    // An vector represents the offsets of alias
+    // e.g: the offset is 2 for the alias `g` of `git`
+    let mut alias_offset = vec![];
+    let mut output = vec![];
+    if let Some(matched_alias) = search_alias(line, working_set) {
+        let mut lens = matched_alias.len();
+        for (input_vec, line_vec) in matched_alias {
+            alias_offset.push(line_vec.len() - input_vec.len());
+            output.extend(line_vec);
+            if lens > 1 {
+                output.push(b' ');
+                lens -= 1;
+            }
+        }
+
+        if !line.is_empty() {
+            let last = line.last().expect("input is empty");
+            if last == &b' ' {
+                output.push(b' ');
+            }
+        }
+    } else {
+        output = line.to_vec();
+    }
+
+    (output, alias_offset)
+}
+
+fn search_alias(input: &[u8], working_set: &StateWorkingSet) -> Option<MatchedAlias> {
+    let mut vec_names = vec![];
+    let mut vec_alias = vec![];
+    let mut pos = 0;
+    let mut is_alias = false;
+    for (index, character) in input.iter().enumerate() {
+        if *character == b' ' {
+            let range = &input[pos..index];
+            vec_names.push(range.to_owned());
+            pos = index + 1;
+        }
+    }
+    // Push the rest to names vector.
+    if pos < input.len() {
+        vec_names.push(input[pos..].to_owned());
+    }
+
+    for name in &vec_names {
+        if let Some(alias_id) = working_set.find_alias(&name[..]) {
+            let alias_span = working_set.get_alias(alias_id);
+            let mut span_vec = vec![];
+            is_alias = true;
+            for alias in alias_span {
+                let name = working_set.get_span_contents(*alias);
+                if !name.is_empty() {
+                    span_vec.push(name);
+                }
+            }
+            // Join span of vector together for complex alias, e.g: `f` is an alias for `git remote -v`
+            let full_aliases = span_vec.join(&[b' '][..]);
+            vec_alias.push(full_aliases);
+        } else {
+            vec_alias.push(name.to_owned());
+        }
+    }
+
+    if is_alias {
+        // Zip names and alias vectors, the original inputs and its aliases mapping.
+        // e.g:(['g'], ['g','i','t'])
+        let output = vec_names.into_iter().zip(vec_alias).collect();
+        Some(output)
+    } else {
+        None
+    }
+}
+
+// reads the most left variable returning it's name (e.g: $myvar)
+// and the depth (a.b.c)
+fn most_left_variable(
+    idx: usize,
+    working_set: &StateWorkingSet<'_>,
+    flattened: Vec<(Span, FlatShape)>,
+) -> Option<(Vec<u8>, Vec<Vec<u8>>)> {
+    // Reverse items to read the list backwards and truncate
+    // because the only items that matters are the ones before the current index
+    let mut rev = flattened;
+    rev.truncate(idx);
+    rev = rev.into_iter().rev().collect();
+
+    // Store the variables and sub levels found and reverse to correct order
+    let mut variables_found: Vec<Vec<u8>> = vec![];
+    let mut found_var = false;
+    for item in rev.clone() {
+        let result = working_set.get_span_contents(item.0).to_vec();
+
+        match item.1 {
+            FlatShape::Variable => {
+                variables_found.push(result);
+                found_var = true;
+
+                break;
+            }
+            FlatShape::String => {
+                variables_found.push(result);
+            }
+            _ => {
+                break;
+            }
+        }
+    }
+
+    // If most left var was not found
+    if !found_var {
+        return None;
+    }
+
+    // Reverse the order back
+    variables_found = variables_found.into_iter().rev().collect();
+
+    // Extract the variable and the sublevels
+    let var = variables_found.first().unwrap_or(&vec![]).to_vec();
+    let sublevels: Vec<Vec<u8>> = variables_found.into_iter().skip(1).collect();
+
+    Some((var, sublevels))
+}
+
+pub fn map_value_completions<'a>(
+    list: impl Iterator<Item = &'a Value>,
+    span: Span,
+    offset: usize,
+) -> Vec<Suggestion> {
+    list.filter_map(move |x| {
+        // Match for string values
+        if let Ok(s) = x.as_string() {
+            return Some(Suggestion {
+                value: s,
+                description: None,
+                extra: None,
+                span: reedline::Span {
+                    start: span.start - offset,
+                    end: span.end - offset,
+                },
+                append_whitespace: false,
+            });
+        }
+
+        // Match for record values
+        if let Ok((cols, vals)) = x.as_record() {
+            let mut suggestion = Suggestion {
+                value: String::from(""), // Initialize with empty string
+                description: None,
+                extra: None,
+                span: reedline::Span {
+                    start: span.start - offset,
+                    end: span.end - offset,
+                },
+                append_whitespace: false,
+            };
+
+            // Iterate the cols looking for `value` and `description`
+            cols.iter().zip(vals).for_each(|it| {
+                // Match `value` column
+                if it.0 == "value" {
+                    // Convert the value to string
+                    if let Ok(val_str) = it.1.as_string() {
+                        // Update the suggestion value
+                        suggestion.value = val_str;
+                    }
+                }
+
+                // Match `description` column
+                if it.0 == "description" {
+                    // Convert the value to string
+                    if let Ok(desc_str) = it.1.as_string() {
+                        // Update the suggestion value
+                        suggestion.description = Some(desc_str);
+                    }
+                }
+            });
+
+            return Some(suggestion);
+        }
+
+        None
+    })
+    .collect()
+}

crates/nu-cli/src/completions/completion_options.rs

@@ -1,25 +1,93 @@
-#[derive(Clone)]
+use std::fmt::Display;
+
+use fuzzy_matcher::{skim::SkimMatcherV2, FuzzyMatcher};
+use nu_parser::trim_quotes_str;
+
+#[derive(Copy, Clone)]
 pub enum SortBy {
     LevenshteinDistance,
     Ascending,
     None,
 }
 
+/// Describes how suggestions should be matched.
+#[derive(Copy, Clone, Debug)]
+pub enum MatchAlgorithm {
+    /// Only show suggestions which begin with the given input
+    ///
+    /// Example:
+    /// "git switch" is matched by "git sw"
+    Prefix,
+
+    /// Only show suggestions which contain the input chars at any place
+    ///
+    /// Example:
+    /// "git checkout" is matched by "gco"
+    Fuzzy,
+}
+
+impl MatchAlgorithm {
+    /// Returns whether the `needle` search text matches the given `haystack`.
+    pub fn matches_str(&self, haystack: &str, needle: &str) -> bool {
+        let haystack = trim_quotes_str(haystack);
+        let needle = trim_quotes_str(needle);
+        match *self {
+            MatchAlgorithm::Prefix => haystack.starts_with(needle),
+            MatchAlgorithm::Fuzzy => {
+                let matcher = SkimMatcherV2::default();
+                matcher.fuzzy_match(haystack, needle).is_some()
+            }
+        }
+    }
+
+    /// Returns whether the `needle` search text matches the given `haystack`.
+    pub fn matches_u8(&self, haystack: &[u8], needle: &[u8]) -> bool {
+        match *self {
+            MatchAlgorithm::Prefix => haystack.starts_with(needle),
+            MatchAlgorithm::Fuzzy => {
+                let haystack_str = String::from_utf8_lossy(haystack);
+                let needle_str = String::from_utf8_lossy(needle);
+
+                let matcher = SkimMatcherV2::default();
+                matcher.fuzzy_match(&haystack_str, &needle_str).is_some()
+            }
+        }
+    }
+}
+
+impl TryFrom<String> for MatchAlgorithm {
+    type Error = InvalidMatchAlgorithm;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        match value.as_str() {
+            "prefix" => Ok(Self::Prefix),
+            "fuzzy" => Ok(Self::Fuzzy),
+            _ => Err(InvalidMatchAlgorithm::Unknown),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum InvalidMatchAlgorithm {
+    Unknown,
+}
+
+impl Display for InvalidMatchAlgorithm {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            InvalidMatchAlgorithm::Unknown => write!(f, "unknown match algorithm"),
+        }
+    }
+}
+
+impl std::error::Error for InvalidMatchAlgorithm {}
+
 #[derive(Clone)]
 pub struct CompletionOptions {
     pub case_sensitive: bool,
     pub positional: bool,
     pub sort_by: SortBy,
-}
-
-impl CompletionOptions {
-    pub fn new(case_sensitive: bool, positional: bool, sort_by: SortBy) -> Self {
-        Self {
-            case_sensitive,
-            positional,
-            sort_by,
-        }
-    }
+    pub match_algorithm: MatchAlgorithm,
 }
 
 impl Default for CompletionOptions {
@@ -28,6 +96,42 @@ impl Default for CompletionOptions {
             case_sensitive: true,
             positional: true,
             sort_by: SortBy::Ascending,
+            match_algorithm: MatchAlgorithm::Prefix,
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::MatchAlgorithm;
+
+    #[test]
+    fn match_algorithm_prefix() {
+        let algorithm = MatchAlgorithm::Prefix;
+
+        assert!(algorithm.matches_str("example text", ""));
+        assert!(algorithm.matches_str("example text", "examp"));
+        assert!(!algorithm.matches_str("example text", "text"));
+
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[1, 2]));
+        assert!(!algorithm.matches_u8(&[1, 2, 3], &[2, 3]));
+    }
+
+    #[test]
+    fn match_algorithm_fuzzy() {
+        let algorithm = MatchAlgorithm::Fuzzy;
+
+        assert!(algorithm.matches_str("example text", ""));
+        assert!(algorithm.matches_str("example text", "examp"));
+        assert!(algorithm.matches_str("example text", "ext"));
+        assert!(algorithm.matches_str("example text", "mplxt"));
+        assert!(!algorithm.matches_str("example text", "mpp"));
+
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[1, 2]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[2, 3]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[1, 3]));
+        assert!(!algorithm.matches_u8(&[1, 2, 3], &[2, 2]));
+    }
+}

crates/nu-cli/src/completions/custom_completions.rs

@@ -1,90 +1,48 @@
-use crate::completions::{Completer, CompletionOptions, SortBy};
+use crate::completions::{Completer, CompletionOptions, MatchAlgorithm, SortBy};
 use nu_engine::eval_call;
 use nu_protocol::{
     ast::{Argument, Call, Expr, Expression},
     engine::{EngineState, Stack, StateWorkingSet},
-    PipelineData, Span, Type, Value, CONFIG_VARIABLE_ID,
+    PipelineData, Span, Type, Value,
 };
 use reedline::Suggestion;
 use std::sync::Arc;
 
+use super::completer::map_value_completions;
+
 pub struct CustomCompletion {
     engine_state: Arc<EngineState>,
     stack: Stack,
-    config: Option<Value>,
     decl_id: usize,
     line: String,
+    sort_by: SortBy,
 }
 
 impl CustomCompletion {
-    pub fn new(
-        engine_state: Arc<EngineState>,
-        stack: Stack,
-        config: Option<Value>,
-        decl_id: usize,
-        line: String,
-    ) -> Self {
+    pub fn new(engine_state: Arc<EngineState>, stack: Stack, decl_id: usize, line: String) -> Self {
         Self {
             engine_state,
             stack,
-            config,
             decl_id,
             line,
+            sort_by: SortBy::None,
         }
     }
-
-    fn map_completions<'a>(
-        &self,
-        list: impl Iterator<Item = &'a Value>,
-        span: Span,
-        offset: usize,
-    ) -> Vec<Suggestion> {
-        list.filter_map(move |x| {
-            let s = x.as_string();
-
-            match s {
-                Ok(s) => Some(Suggestion {
-                    value: s,
-                    description: None,
-                    extra: None,
-                    span: reedline::Span {
-                        start: span.start - offset,
-                        end: span.end - offset,
-                    },
-                }),
-                Err(_) => None,
-            }
-        })
-        .collect()
-    }
 }
 
 impl Completer for CustomCompletion {
     fn fetch(
         &mut self,
         _: &StateWorkingSet,
-        _: Vec<u8>,
+        prefix: Vec<u8>,
         span: Span,
         offset: usize,
         pos: usize,
-    ) -> (Vec<Suggestion>, CompletionOptions) {
+        completion_options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
         // Line position
         let line_pos = pos - offset;
 
-        // Set up our initial config to start from
-        if let Some(conf) = &self.config {
-            self.stack.vars.insert(CONFIG_VARIABLE_ID, conf.clone());
-        } else {
-            self.stack.vars.insert(
-                CONFIG_VARIABLE_ID,
-                Value::Record {
-                    cols: vec![],
-                    vals: vec![],
-                    span: Span { start: 0, end: 0 },
-                },
-            );
-        }
-
         // Call custom declaration
         let result = eval_call(
             &self.engine_state,
@@ -112,8 +70,10 @@ impl Completer for CustomCompletion {
             PipelineData::new(span),
         );
 
+        let mut custom_completion_options = None;
+
         // Parse result
-        let (suggestions, options) = match result {
+        let suggestions = match result {
             Ok(pd) => {
                 let value = pd.into_value(span);
                 match &value {
@@ -123,19 +83,23 @@ impl Completer for CustomCompletion {
                             .and_then(|val| {
                                 val.as_list()
                                     .ok()
-                                    .map(|it| self.map_completions(it.iter(), span, offset))
+                                    .map(|it| map_value_completions(it.iter(), span, offset))
                             })
                             .unwrap_or_default();
                         let options = value.get_data_by_key("options");
 
-                        let options = if let Some(Value::Record { .. }) = &options {
+                        if let Some(Value::Record { .. }) = &options {
                             let options = options.unwrap_or_default();
                             let should_sort = options
                                 .get_data_by_key("sort")
                                 .and_then(|val| val.as_bool().ok())
                                 .unwrap_or(false);
 
-                            CompletionOptions {
+                            if should_sort {
+                                self.sort_by = SortBy::Ascending;
+                            }
+
+                            custom_completion_options = Some(CompletionOptions {
                                 case_sensitive: options
                                     .get_data_by_key("case_sensitive")
                                     .and_then(|val| val.as_bool().ok())
@@ -149,23 +113,60 @@ impl Completer for CustomCompletion {
                                 } else {
                                     SortBy::None
                                 },
+                                match_algorithm: match options
+                                    .get_data_by_key("completion_algorithm")
+                                {
+                                    Some(option) => option
+                                        .as_string()
+                                        .ok()
+                                        .and_then(|option| option.try_into().ok())
+                                        .unwrap_or(MatchAlgorithm::Prefix),
+                                    None => completion_options.match_algorithm,
+                                },
+                            });
                         }
+
+                        completions
+                    }
+                    Value::List { vals, .. } => map_value_completions(vals.iter(), span, offset),
+                    _ => vec![],
+                }
+            }
+            _ => vec![],
+        };
+
+        if let Some(custom_completion_options) = custom_completion_options {
+            filter(&prefix, suggestions, &custom_completion_options)
         } else {
-                            CompletionOptions::default()
-                        };
+            filter(&prefix, suggestions, completion_options)
+        }
+    }
 
-                        (completions, options)
-                    }
-                    Value::List { vals, .. } => {
-                        let completions = self.map_completions(vals.iter(), span, offset);
-                        (completions, CompletionOptions::default())
-                    }
-                    _ => (vec![], CompletionOptions::default()),
-                }
-            }
-            _ => (vec![], CompletionOptions::default()),
-        };
-
-        (suggestions, options)
+    fn get_sort_by(&self) -> SortBy {
+        self.sort_by
     }
 }
+
+fn filter(prefix: &[u8], items: Vec<Suggestion>, options: &CompletionOptions) -> Vec<Suggestion> {
+    items
+        .into_iter()
+        .filter(|it| match options.match_algorithm {
+            MatchAlgorithm::Prefix => match (options.case_sensitive, options.positional) {
+                (true, true) => it.value.as_bytes().starts_with(prefix),
+                (true, false) => it.value.contains(std::str::from_utf8(prefix).unwrap_or("")),
+                (false, positional) => {
+                    let value = it.value.to_lowercase();
+                    let prefix = std::str::from_utf8(prefix).unwrap_or("").to_lowercase();
+                    if positional {
+                        value.starts_with(&prefix)
+                    } else {
+                        value.contains(&prefix)
+                    }
+                }
+            },
+            MatchAlgorithm::Fuzzy => options
+                .match_algorithm
+                .matches_u8(it.value.as_bytes(), prefix),
+        })
+        .collect()
+}

crates/nu-cli/src/completions/directory_completions.rs

@@ -0,0 +1,160 @@
+use crate::completions::{matches, Completer, CompletionOptions};
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    levenshtein_distance, Span,
+};
+use reedline::Suggestion;
+use std::fs;
+use std::path::Path;
+use std::sync::Arc;
+
+use super::{partial_from, prepend_base_dir};
+
+const SEP: char = std::path::MAIN_SEPARATOR;
+
+#[derive(Clone)]
+pub struct DirectoryCompletion {
+    engine_state: Arc<EngineState>,
+}
+
+impl DirectoryCompletion {
+    pub fn new(engine_state: Arc<EngineState>) -> Self {
+        Self { engine_state }
+    }
+}
+
+impl Completer for DirectoryCompletion {
+    fn fetch(
+        &mut self,
+        _: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        _: usize,
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
+        let cwd = if let Some(d) = self.engine_state.get_env_var("PWD") {
+            match d.as_string() {
+                Ok(s) => s,
+                Err(_) => "".to_string(),
+            }
+        } else {
+            "".to_string()
+        };
+        let partial = String::from_utf8_lossy(&prefix).to_string();
+
+        // Filter only the folders
+        let output: Vec<_> = directory_completion(span, &partial, &cwd, options)
+            .into_iter()
+            .map(move |x| Suggestion {
+                value: x.1,
+                description: None,
+                extra: None,
+                span: reedline::Span {
+                    start: x.0.start - offset,
+                    end: x.0.end - offset,
+                },
+                append_whitespace: false,
+            })
+            .collect();
+
+        output
+    }
+
+    // Sort results prioritizing the non hidden folders
+    fn sort(&self, items: Vec<Suggestion>, prefix: Vec<u8>) -> Vec<Suggestion> {
+        let prefix_str = String::from_utf8_lossy(&prefix).to_string();
+
+        // Sort items
+        let mut sorted_items = items;
+        sorted_items.sort_by(|a, b| a.value.cmp(&b.value));
+        sorted_items.sort_by(|a, b| {
+            let a_distance = levenshtein_distance(&prefix_str, &a.value);
+            let b_distance = levenshtein_distance(&prefix_str, &b.value);
+            a_distance.cmp(&b_distance)
+        });
+
+        // Separate the results between hidden and non hidden
+        let mut hidden: Vec<Suggestion> = vec![];
+        let mut non_hidden: Vec<Suggestion> = vec![];
+
+        for item in sorted_items.into_iter() {
+            let item_path = Path::new(&item.value);
+
+            if let Some(value) = item_path.file_name() {
+                if let Some(value) = value.to_str() {
+                    if value.starts_with('.') {
+                        hidden.push(item);
+                    } else {
+                        non_hidden.push(item);
+                    }
+                }
+            }
+        }
+
+        // Append the hidden folders to the non hidden vec to avoid creating a new vec
+        non_hidden.append(&mut hidden);
+
+        non_hidden
+    }
+}
+
+pub fn directory_completion(
+    span: nu_protocol::Span,
+    partial: &str,
+    cwd: &str,
+    options: &CompletionOptions,
+) -> Vec<(nu_protocol::Span, String)> {
+    let original_input = partial;
+
+    let (base_dir_name, partial) = partial_from(partial);
+
+    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() {
+        return result
+            .filter_map(|entry| {
+                entry.ok().and_then(|entry| {
+                    if let Ok(metadata) = fs::metadata(entry.path()) {
+                        if metadata.is_dir() {
+                            let mut file_name = entry.file_name().to_string_lossy().into_owned();
+                            if matches(&partial, &file_name, options) {
+                                let mut path = if prepend_base_dir(original_input, &base_dir_name) {
+                                    format!("{}{}", base_dir_name, file_name)
+                                } else {
+                                    file_name.to_string()
+                                };
+
+                                if entry.path().is_dir() {
+                                    path.push(SEP);
+                                    file_name.push(SEP);
+                                }
+
+                                // Fix files or folders with quotes
+                                if path.contains('\'') || path.contains('"') || path.contains(' ') {
+                                    path = format!("`{}`", path);
+                                }
+
+                                Some((span, path))
+                            } else {
+                                None
+                            }
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                })
+            })
+            .collect();
+    }
+
+    Vec::new()
+}

crates/nu-cli/src/completions/dotnu_completions.rs

@@ -0,0 +1,124 @@
+use crate::completions::{
+    file_path_completion, partial_from, Completer, CompletionOptions, SortBy,
+};
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    Span,
+};
+use reedline::Suggestion;
+use std::sync::Arc;
+const SEP: char = std::path::MAIN_SEPARATOR;
+
+#[derive(Clone)]
+pub struct DotNuCompletion {
+    engine_state: Arc<EngineState>,
+}
+
+impl DotNuCompletion {
+    pub fn new(engine_state: Arc<EngineState>) -> Self {
+        Self { engine_state }
+    }
+}
+
+impl Completer for DotNuCompletion {
+    fn fetch(
+        &mut self,
+        _: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        _: usize,
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
+        let prefix_str = String::from_utf8_lossy(&prefix).to_string();
+        let mut search_dirs: Vec<String> = vec![];
+        let (base_dir, mut partial) = partial_from(&prefix_str);
+        let mut is_current_folder = false;
+
+        // Fetch the lib dirs
+        let lib_dirs: Vec<String> =
+            if let Some(lib_dirs) = self.engine_state.get_env_var("NU_LIB_DIRS") {
+                lib_dirs
+                    .as_list()
+                    .into_iter()
+                    .flat_map(|it| {
+                        it.iter().map(|x| {
+                            x.as_path()
+                                .expect("internal error: failed to convert lib path")
+                        })
+                    })
+                    .map(|it| {
+                        it.into_os_string()
+                            .into_string()
+                            .expect("internal error: failed to convert OS path")
+                    })
+                    .collect()
+            } else {
+                vec![]
+            };
+
+        // Check if the base_dir is a folder
+        if base_dir != format!(".{}", SEP) {
+            // Add the base dir into the directories to be searched
+            search_dirs.push(base_dir.clone());
+
+            // Reset the partial adding the basic dir back
+            // in order to make the span replace work properly
+            let mut base_dir_partial = base_dir;
+            base_dir_partial.push_str(&partial);
+
+            partial = base_dir_partial;
+        } else {
+            // Fetch the current folder
+            let current_folder = if let Some(d) = self.engine_state.get_env_var("PWD") {
+                match d.as_string() {
+                    Ok(s) => s,
+                    Err(_) => "".to_string(),
+                }
+            } else {
+                "".to_string()
+            };
+            is_current_folder = true;
+
+            // Add the current folder and the lib dirs into the
+            // directories to be searched
+            search_dirs.push(current_folder);
+            search_dirs.extend(lib_dirs);
+        }
+
+        // Fetch the files filtering the ones that ends with .nu
+        // and transform them into suggestions
+        let output: Vec<Suggestion> = search_dirs
+            .into_iter()
+            .flat_map(|it| {
+                file_path_completion(span, &partial, &it, options)
+                    .into_iter()
+                    .filter(|it| {
+                        // Different base dir, so we list the .nu files or folders
+                        if !is_current_folder {
+                            it.1.ends_with(".nu") || it.1.ends_with(SEP)
+                        } else {
+                            // Lib dirs, so we filter only the .nu files
+                            it.1.ends_with(".nu")
+                        }
+                    })
+                    .map(move |x| Suggestion {
+                        value: x.1,
+                        description: None,
+                        extra: None,
+                        span: reedline::Span {
+                            start: x.0.start - offset,
+                            end: x.0.end - offset,
+                        },
+                        append_whitespace: true,
+                    })
+            })
+            .collect();
+
+        output
+    }
+
+    fn get_sort_by(&self) -> SortBy {
+        SortBy::LevenshteinDistance
+    }
+}

crates/nu-cli/src/completions/file_completions.rs

@@ -28,8 +28,9 @@ impl Completer for FileCompletion {
         span: Span,
         offset: usize,
         _: usize,
-    ) -> (Vec<Suggestion>, CompletionOptions) {
-        let cwd = if let Some(d) = self.engine_state.env_vars.get("PWD") {
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
+        let cwd = if let Some(d) = self.engine_state.get_env_var("PWD") {
             match d.as_string() {
                 Ok(s) => s,
                 Err(_) => "".to_string(),
@@ -38,7 +39,7 @@ impl Completer for FileCompletion {
             "".to_string()
         };
         let prefix = String::from_utf8_lossy(&prefix).to_string();
-        let output: Vec<_> = file_path_completion(span, &prefix, &cwd)
+        let output: Vec<_> = file_path_completion(span, &prefix, &cwd, options)
             .into_iter()
             .map(move |x| Suggestion {
                 value: x.1,
@@ -48,26 +49,20 @@ impl Completer for FileCompletion {
                     start: x.0.start - offset,
                     end: x.0.end - offset,
                 },
+                append_whitespace: false,
             })
             .collect();
 
-        // Options
-        let options = CompletionOptions::default();
-
-        (output, options)
+        output
     }
 
     // Sort results prioritizing the non hidden folders
-    fn sort(
-        &self,
-        items: Vec<Suggestion>,
-        prefix: Vec<u8>,
-        _: CompletionOptions, // Ignore the given options, once it's a custom sorting
-    ) -> Vec<Suggestion> {
+    fn sort(&self, items: Vec<Suggestion>, prefix: Vec<u8>) -> Vec<Suggestion> {
         let prefix_str = String::from_utf8_lossy(&prefix).to_string();
 
         // Sort items
         let mut sorted_items = items;
+        sorted_items.sort_by(|a, b| a.value.cmp(&b.value));
         sorted_items.sort_by(|a, b| {
             let a_distance = levenshtein_distance(&prefix_str, &a.value);
             let b_distance = levenshtein_distance(&prefix_str, &b.value);
@@ -97,21 +92,11 @@ impl Completer for FileCompletion {
 
         non_hidden
     }
-
-    // Replace base filter with no filter once all the results are already based in the current path
-    fn filter(&self, _: Vec<u8>, items: Vec<Suggestion>, _: CompletionOptions) -> Vec<Suggestion> {
-        items
-    }
 }
 
-pub fn file_path_completion(
-    span: nu_protocol::Span,
-    partial: &str,
-    cwd: &str,
-) -> Vec<(nu_protocol::Span, String)> {
-    let partial = partial.replace('\'', "");
+pub fn partial_from(input: &str) -> (String, String) {
+    let partial = input.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 \
@@ -119,8 +104,18 @@ pub fn file_path_completion(
 
     // rsplit_once removes the separator
     base.push(SEP);
-        (base, rest)
-    };
+
+    (base.to_string(), rest.to_string())
+}
+
+pub fn file_path_completion(
+    span: nu_protocol::Span,
+    partial: &str,
+    cwd: &str,
+    options: &CompletionOptions,
+) -> Vec<(nu_protocol::Span, String)> {
+    let original_input = partial;
+    let (base_dir_name, partial) = partial_from(partial);
 
     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
@@ -134,15 +129,21 @@ pub fn file_path_completion(
             .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 matches(&partial, &file_name, options) {
+                        let mut path = if prepend_base_dir(original_input, &base_dir_name) {
+                            format!("{}{}", base_dir_name, file_name)
+                        } else {
+                            file_name.to_string()
+                        };
+
                         if entry.path().is_dir() {
                             path.push(SEP);
                             file_name.push(SEP);
                         }
 
-                        if path.contains(' ') {
-                            path = format!("\'{}\'", path);
+                        // Fix files or folders with quotes
+                        if path.contains('\'') || path.contains('"') || path.contains(' ') {
+                            path = format!("`{}`", path);
                         }
 
                         Some((span, path))
@@ -157,7 +158,33 @@ pub fn file_path_completion(
     Vec::new()
 }
 
-pub fn matches(partial: &str, from: &str) -> bool {
-    from.to_ascii_lowercase()
-        .starts_with(&partial.to_ascii_lowercase())
+pub fn matches(partial: &str, from: &str, options: &CompletionOptions) -> bool {
+    // Check for case sensitive
+    if !options.case_sensitive {
+        return options
+            .match_algorithm
+            .matches_str(&from.to_ascii_lowercase(), &partial.to_ascii_lowercase());
+    }
+
+    options.match_algorithm.matches_str(from, partial)
+}
+
+/// Returns whether the base_dir should be prepended to the file path
+pub fn prepend_base_dir(input: &str, base_dir: &str) -> bool {
+    if base_dir == format!(".{}", SEP) {
+        // if the current base_dir path is the local folder we only add a "./" prefix if the user
+        // input already includes a local folder prefix.
+        let manually_entered = {
+            let mut chars = input.chars();
+            let first_char = chars.next();
+            let second_char = chars.next();
+
+            first_char == Some('.') && second_char.map(is_separator).unwrap_or(false)
+        };
+
+        manually_entered
+    } else {
+        // always prepend the base dir if it is a subfolder
+        true
+    }
 }

crates/nu-cli/src/completions/flag_completions.rs

@@ -26,7 +26,8 @@ impl Completer for FlagCompletion {
         span: Span,
         offset: usize,
         _: usize,
-    ) -> (Vec<Suggestion>, CompletionOptions) {
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
         // Check if it's a flag
         if let Expr::Call(call) = &self.expression.expr {
             let decl = working_set.get_decl(call.decl_id);
@@ -40,7 +41,8 @@ impl Completer for FlagCompletion {
                     let mut named = vec![0; short.len_utf8()];
                     short.encode_utf8(&mut named);
                     named.insert(0, b'-');
-                    if named.starts_with(&prefix) {
+
+                    if options.match_algorithm.matches_u8(&named, &prefix) {
                         output.push(Suggestion {
                             value: String::from_utf8_lossy(&named).to_string(),
                             description: Some(flag_desc.to_string()),
@@ -49,6 +51,7 @@ impl Completer for FlagCompletion {
                                 start: span.start - offset,
                                 end: span.end - offset,
                             },
+                            append_whitespace: true,
                         });
                     }
                 }
@@ -60,7 +63,8 @@ impl Completer for FlagCompletion {
                 let mut named = named.long.as_bytes().to_vec();
                 named.insert(0, b'-');
                 named.insert(0, b'-');
-                if named.starts_with(&prefix) {
+
+                if options.match_algorithm.matches_u8(&named, &prefix) {
                     output.push(Suggestion {
                         value: String::from_utf8_lossy(&named).to_string(),
                         description: Some(flag_desc.to_string()),
@@ -69,13 +73,14 @@ impl Completer for FlagCompletion {
                             start: span.start - offset,
                             end: span.end - offset,
                         },
+                        append_whitespace: true,
                     });
                 }
             }
 
-            return (output, CompletionOptions::default());
+            return output;
         }
 
-        (vec![], CompletionOptions::default())
+        vec![]
     }
 }

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

@@ -3,6 +3,8 @@ mod command_completions;
 mod completer;
 mod completion_options;
 mod custom_completions;
+mod directory_completions;
+mod dotnu_completions;
 mod file_completions;
 mod flag_completions;
 mod variable_completions;
@@ -10,8 +12,12 @@ mod variable_completions;
 pub use base::Completer;
 pub use command_completions::CommandCompletion;
 pub use completer::NuCompleter;
-pub use completion_options::{CompletionOptions, SortBy};
+pub use completion_options::{CompletionOptions, MatchAlgorithm, SortBy};
 pub use custom_completions::CustomCompletion;
-pub use file_completions::{file_path_completion, FileCompletion};
+pub use directory_completions::DirectoryCompletion;
+pub use dotnu_completions::DotNuCompletion;
+pub use file_completions::{
+    file_path_completion, matches, partial_from, prepend_base_dir, FileCompletion,
+};
 pub use flag_completions::FlagCompletion;
 pub use variable_completions::VariableCompletion;

crates/nu-cli/src/completions/variable_completions.rs

@@ -1,19 +1,32 @@
 use crate::completions::{Completer, CompletionOptions};
+use nu_engine::eval_variable;
 use nu_protocol::{
-    engine::{EngineState, StateWorkingSet},
-    Span,
+    engine::{EngineState, Stack, StateWorkingSet},
+    Span, Value,
 };
+
 use reedline::Suggestion;
+use std::str;
 use std::sync::Arc;
 
 #[derive(Clone)]
 pub struct VariableCompletion {
-    engine_state: Arc<EngineState>,
+    engine_state: Arc<EngineState>, // TODO: Is engine state necessary? It's already a part of working set in fetch()
+    stack: Stack,
+    var_context: (Vec<u8>, Vec<Vec<u8>>), // tuple with $var and the sublevels (.b.c.d)
 }
 
 impl VariableCompletion {
-    pub fn new(engine_state: Arc<EngineState>) -> Self {
-        Self { engine_state }
+    pub fn new(
+        engine_state: Arc<EngineState>,
+        stack: Stack,
+        var_context: (Vec<u8>, Vec<Vec<u8>>),
+    ) -> Self {
+        Self {
+            engine_state,
+            stack,
+            var_context,
+        }
     }
 }
 
@@ -25,58 +38,255 @@ impl Completer for VariableCompletion {
         span: Span,
         offset: usize,
         _: usize,
-    ) -> (Vec<Suggestion>, CompletionOptions) {
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
         let mut output = vec![];
+        let builtins = ["$nu", "$in", "$env", "$nothing"];
+        let var_str = std::str::from_utf8(&self.var_context.0)
+            .unwrap_or("")
+            .to_lowercase();
+        let var_id = working_set.find_variable(&self.var_context.0);
+        let current_span = reedline::Span {
+            start: span.start - offset,
+            end: span.end - offset,
+        };
+        let sublevels_count = self.var_context.1.len();
 
-        let builtins = ["$nu", "$in", "$config", "$env", "$nothing"];
+        // Completions for the given variable
+        if !var_str.is_empty() {
+            // Completion for $env.<tab>
+            if var_str.as_str() == "$env" {
+                let env_vars = self.stack.get_env_vars(&self.engine_state);
 
+                // Return nested values
+                if sublevels_count > 0 {
+                    // Extract the target var ($env.<target-var>)
+                    let target_var = self.var_context.1[0].clone();
+                    let target_var_str =
+                        str::from_utf8(&target_var).unwrap_or_default().to_string();
+
+                    // Everything after the target var is the nested level ($env.<target-var>.<nested_levels>...)
+                    let nested_levels: Vec<Vec<u8>> =
+                        self.var_context.1.clone().into_iter().skip(1).collect();
+
+                    if let Some(val) = env_vars.get(&target_var_str) {
+                        for suggestion in
+                            nested_suggestions(val.clone(), nested_levels, current_span)
+                        {
+                            if options
+                                .match_algorithm
+                                .matches_u8(suggestion.value.as_bytes(), &prefix)
+                            {
+                                output.push(suggestion);
+                            }
+                        }
+
+                        return output;
+                    }
+                } else {
+                    // No nesting provided, return all env vars
+                    for env_var in env_vars {
+                        if options
+                            .match_algorithm
+                            .matches_u8(env_var.0.as_bytes(), &prefix)
+                        {
+                            output.push(Suggestion {
+                                value: env_var.0,
+                                description: None,
+                                extra: None,
+                                span: current_span,
+                                append_whitespace: false,
+                            });
+                        }
+                    }
+
+                    return output;
+                }
+            }
+
+            // Completions for $nu.<tab>
+            if var_str.as_str() == "$nu" {
+                // Eval nu var
+                if let Ok(nuval) = eval_variable(
+                    &self.engine_state,
+                    &self.stack,
+                    nu_protocol::NU_VARIABLE_ID,
+                    nu_protocol::Span {
+                        start: current_span.start,
+                        end: current_span.end,
+                    },
+                ) {
+                    for suggestion in
+                        nested_suggestions(nuval, self.var_context.1.clone(), current_span)
+                    {
+                        if options
+                            .match_algorithm
+                            .matches_u8(suggestion.value.as_bytes(), &prefix)
+                        {
+                            output.push(suggestion);
+                        }
+                    }
+
+                    return output;
+                }
+            }
+
+            // Completion other variable types
+            if let Some(var_id) = var_id {
+                // Extract the variable value from the stack
+                let var = self.stack.get_var(
+                    var_id,
+                    Span {
+                        start: span.start,
+                        end: span.end,
+                    },
+                );
+
+                // If the value exists and it's of type Record
+                if let Ok(value) = var {
+                    for suggestion in
+                        nested_suggestions(value, self.var_context.1.clone(), current_span)
+                    {
+                        if options
+                            .match_algorithm
+                            .matches_u8(suggestion.value.as_bytes(), &prefix)
+                        {
+                            output.push(suggestion);
+                        }
+                    }
+
+                    return output;
+                }
+            }
+        }
+
+        // Variable completion (e.g: $en<tab> to complete $env)
         for builtin in builtins {
-            if builtin.as_bytes().starts_with(&prefix) {
+            if options
+                .match_algorithm
+                .matches_u8(builtin.as_bytes(), &prefix)
+            {
                 output.push(Suggestion {
                     value: builtin.to_string(),
                     description: None,
                     extra: None,
-                    span: reedline::Span {
-                        start: span.start - offset,
-                        end: span.end - offset,
-                    },
+                    span: current_span,
+                    append_whitespace: false,
                 });
             }
         }
 
-        for scope in &working_set.delta.scope {
-            for v in &scope.vars {
-                if v.0.starts_with(&prefix) {
+        // TODO: The following can be refactored (see find_commands_by_predicate() used in
+        // command_completions).
+        let mut removed_overlays = vec![];
+        // Working set scope vars
+        for scope_frame in working_set.delta.scope.iter().rev() {
+            for overlay_frame in scope_frame
+                .active_overlays(&mut removed_overlays)
+                .iter()
+                .rev()
+            {
+                for v in &overlay_frame.vars {
+                    if options.match_algorithm.matches_u8(v.0, &prefix) {
                         output.push(Suggestion {
                             value: String::from_utf8_lossy(v.0).to_string(),
                             description: None,
                             extra: None,
-                        span: reedline::Span {
-                            start: span.start - offset,
-                            end: span.end - offset,
-                        },
+                            span: current_span,
+                            append_whitespace: false,
                         });
                     }
                 }
             }
-        for scope in &self.engine_state.scope {
-            for v in &scope.vars {
-                if v.0.starts_with(&prefix) {
+        }
+
+        // Permanent state vars
+        // for scope in &self.engine_state.scope {
+        for overlay_frame in self
+            .engine_state
+            .active_overlays(&removed_overlays)
+            .iter()
+            .rev()
+        {
+            for v in &overlay_frame.vars {
+                if options.match_algorithm.matches_u8(v.0, &prefix) {
                     output.push(Suggestion {
                         value: String::from_utf8_lossy(v.0).to_string(),
                         description: None,
                         extra: None,
-                        span: reedline::Span {
-                            start: span.start - offset,
-                            end: span.end - offset,
-                        },
+                        span: current_span,
+                        append_whitespace: false,
                     });
                 }
             }
         }
 
-        output.dedup();
+        output.dedup(); // TODO: Removes only consecutive duplicates, is it intended?
 
-        (output, CompletionOptions::default())
+        output
     }
 }
+
+// Find recursively the values for sublevels
+// if no sublevels are set it returns the current value
+fn nested_suggestions(
+    val: Value,
+    sublevels: Vec<Vec<u8>>,
+    current_span: reedline::Span,
+) -> Vec<Suggestion> {
+    let mut output: Vec<Suggestion> = vec![];
+    let value = recursive_value(val, sublevels);
+
+    match value {
+        Value::Record {
+            cols,
+            vals: _,
+            span: _,
+        } => {
+            // Add all the columns as completion
+            for item in cols {
+                output.push(Suggestion {
+                    value: item,
+                    description: None,
+                    extra: None,
+                    span: current_span,
+                    append_whitespace: false,
+                });
+            }
+
+            output
+        }
+
+        _ => output,
+    }
+}
+
+// Extracts the recursive value (e.g: $var.a.b.c)
+fn recursive_value(val: Value, sublevels: Vec<Vec<u8>>) -> Value {
+    // Go to next sublevel
+    if let Some(next_sublevel) = sublevels.clone().into_iter().next() {
+        match val {
+            Value::Record {
+                cols,
+                vals,
+                span: _,
+            } => {
+                for item in cols.into_iter().zip(vals.into_iter()) {
+                    // Check if index matches with sublevel
+                    if item.0.as_bytes().to_vec() == next_sublevel {
+                        // If matches try to fetch recursively the next
+                        return recursive_value(item.1, sublevels.into_iter().skip(1).collect());
+                    }
+                }
+
+                // Current sublevel value not found
+                return Value::Nothing {
+                    span: Span { start: 0, end: 0 },
+                };
+            }
+            _ => return val,
+        }
+    }
+
+    val
+}

crates/nu-cli/src/config_files.rs

@@ -1,27 +1,36 @@
 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};
+#[cfg(feature = "plugin")]
+use nu_parser::ParseError;
+#[cfg(feature = "plugin")]
+use nu_path::canonicalize_with;
+use nu_protocol::engine::{EngineState, Stack, StateWorkingSet};
+#[cfg(feature = "plugin")]
+use nu_protocol::Spanned;
+use nu_protocol::{HistoryFileFormat, PipelineData, Span};
 use std::path::PathBuf;
 
 #[cfg(feature = "plugin")]
 const PLUGIN_FILE: &str = "plugin.nu";
 
+const HISTORY_FILE_TXT: &str = "history.txt";
+const HISTORY_FILE_SQLITE: &str = "history.sqlite3";
+
 #[cfg(feature = "plugin")]
 pub fn read_plugin_file(
     engine_state: &mut EngineState,
     stack: &mut Stack,
+    plugin_file: Option<Spanned<String>>,
     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);
+    add_plugin_file(engine_state, plugin_file, 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();
+        let plugin_filename = plugin_path.to_string_lossy();
 
         if let Ok(contents) = std::fs::read(&plugin_path) {
             eval_source(
@@ -34,14 +43,27 @@ pub fn read_plugin_file(
         }
     }
 
-    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() {
+pub fn add_plugin_file(
+    engine_state: &mut EngineState,
+    plugin_file: Option<Spanned<String>>,
+    storage_path: &str,
+) {
+    if let Some(plugin_file) = plugin_file {
+        let working_set = StateWorkingSet::new(engine_state);
+        let cwd = working_set.get_cwd();
+
+        match canonicalize_with(&plugin_file.item, cwd) {
+            Ok(path) => engine_state.plugin_signatures = Some(path),
+            Err(_) => {
+                let e = ParseError::FileNotFound(plugin_file.item, plugin_file.span);
+                report_error(&working_set, &e);
+            }
+        }
+    } else 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);
@@ -55,7 +77,7 @@ pub fn eval_config_contents(
     stack: &mut Stack,
 ) {
     if config_path.exists() & config_path.is_file() {
-        let config_filename = config_path.to_string_lossy().to_owned();
+        let config_filename = config_path.to_string_lossy();
 
         if let Ok(contents) = std::fs::read(&config_path) {
             eval_source(
@@ -66,10 +88,10 @@ pub fn eval_config_contents(
                 PipelineData::new(Span::new(0, 0)),
             );
 
-            // Merge the delta in case env vars changed in the config
+            // Merge the environment 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) {
+                    if let Err(e) = engine_state.merge_env(stack, cwd) {
                         let working_set = StateWorkingSet::new(engine_state);
                         report_error(&working_set, &e);
                     }
@@ -82,3 +104,14 @@ pub fn eval_config_contents(
         }
     }
 }
+
+pub(crate) fn get_history_path(storage_path: &str, mode: HistoryFileFormat) -> Option<PathBuf> {
+    nu_path::config_dir().map(|mut history_path| {
+        history_path.push(storage_path);
+        history_path.push(match mode {
+            HistoryFileFormat::PlainText => HISTORY_FILE_TXT,
+            HistoryFileFormat::Sqlite => HISTORY_FILE_SQLITE,
+        });
+        history_path
+    })
+}

crates/nu-cli/src/eval_file.rs

@@ -4,12 +4,13 @@ use log::trace;
 use miette::{IntoDiagnostic, Result};
 use nu_engine::convert_env_values;
 use nu_parser::parse;
+use nu_protocol::Type;
 use nu_protocol::{
     ast::Call,
     engine::{EngineState, Stack, StateWorkingSet},
     Config, PipelineData, Span, Value,
 };
-use std::io::Write;
+use nu_utils::stdout_write_all_and_flush;
 
 /// Main function used when a file path is found as argument for nu
 pub fn evaluate_file(
@@ -18,7 +19,6 @@ pub fn evaluate_file(
     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) {
@@ -29,12 +29,14 @@ pub fn evaluate_file(
 
     let file = std::fs::read(&path).into_diagnostic()?;
 
+    engine_state.start_in_file(Some(&path));
+
     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() {
+    if working_set.find_decl(b"main", &Type::Any).is_some() {
         let args = format!("main {}", args.join(" "));
 
         if !eval_source(
@@ -53,27 +55,40 @@ pub fn evaluate_file(
         std::process::exit(1);
     }
 
-    if is_perf_true {
     info!("evaluate {}:{}:{}", file!(), line!(), column!());
-    }
 
     Ok(())
 }
 
 pub fn print_table_or_error(
-    engine_state: &EngineState,
+    engine_state: &mut EngineState,
     stack: &mut Stack,
     mut pipeline_data: PipelineData,
-    config: &Config,
-) {
+    config: &mut Config,
+) -> Option<i64> {
     let exit_code = match &mut pipeline_data {
         PipelineData::ExternalStream { exit_code, .. } => exit_code.take(),
         _ => None,
     };
 
-    match engine_state.find_decl("table".as_bytes()) {
+    // Change the engine_state config to use the passed in configuration
+    engine_state.set_config(config);
+
+    if let PipelineData::Value(Value::Error { error }, ..) = &pipeline_data {
+        let working_set = StateWorkingSet::new(engine_state);
+
+        report_error(&working_set, error);
+
+        std::process::exit(1);
+    }
+
+    match engine_state.find_decl("table".as_bytes(), &[]) {
         Some(decl_id) => {
-            let table = engine_state.get_decl(decl_id).run(
+            let command = engine_state.get_decl(decl_id);
+            if command.get_block_id().is_some() {
+                print_or_exit(pipeline_data, engine_state, config);
+            } else {
+                let table = command.run(
                     engine_state,
                     stack,
                     &Call::new(Span::new(0, 0)),
@@ -82,25 +97,7 @@ pub fn print_table_or_error(
 
                 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),
-                        };
-                    }
+                        print_or_exit(table, engine_state, config);
                     }
                     Err(error) => {
                         let working_set = StateWorkingSet::new(engine_state);
@@ -111,10 +108,28 @@ pub fn print_table_or_error(
                     }
                 }
             }
+        }
         None => {
-            for item in pipeline_data {
-                let stdout = std::io::stdout();
+            print_or_exit(pipeline_data, engine_state, config);
+        }
+    };
 
+    // Make sure everything has finished
+    if let Some(exit_code) = exit_code {
+        let mut exit_code: Vec<_> = exit_code.into_iter().collect();
+        exit_code
+            .pop()
+            .and_then(|last_exit_code| match last_exit_code {
+                Value::Int { val: code, .. } => Some(code),
+                _ => None,
+            })
+    } else {
+        None
+    }
+}
+
+fn print_or_exit(pipeline_data: PipelineData, engine_state: &mut EngineState, config: &Config) {
+    for item in pipeline_data {
         if let Value::Error { error } = item {
             let working_set = StateWorkingSet::new(engine_state);
 
@@ -126,16 +141,6 @@ pub fn print_table_or_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),
-                };
-            }
-        }
-    };
-
-    // Make sure everything has finished
-    if let Some(exit_code) = exit_code {
-        let _: Vec<_> = exit_code.into_iter().collect();
+        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
     }
 }

crates/nu-cli/src/lib.rs

@@ -1,7 +1,6 @@
 mod commands;
 mod completions;
 mod config_files;
-mod errors;
 mod eval_file;
 mod menus;
 mod nu_highlight;
@@ -15,18 +14,17 @@ mod util;
 mod validation;
 
 pub use commands::evaluate_commands;
-pub use completions::NuCompleter;
+pub use completions::{FileCompletion, NuCompleter};
 pub use config_files::eval_config_contents;
-pub use errors::CliError;
 pub use eval_file::evaluate_file;
 pub use menus::{DescriptionMenu, NuHelpCompleter};
 pub use nu_highlight::NuHighlight;
 pub use print::Print;
 pub use prompt::NushellPrompt;
 pub use repl::evaluate_repl;
+pub use repl::{eval_env_change_hook, eval_hook};
 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 util::{eval_source, gather_parent_env_vars, get_init_cwd, report_error, report_error_new};
 pub use validation::NuValidator;
 
 #[cfg(feature = "plugin")]

crates/nu-cli/src/menus/description_menu.rs

@@ -1,8 +1,8 @@
 use {
     nu_ansi_term::{ansi::RESET, Style},
     reedline::{
-        menu_functions::string_difference, Completer, LineBuffer, Menu, MenuEvent, MenuTextStyle,
-        Painter, Suggestion,
+        menu_functions::string_difference, Completer, Editor, Menu, MenuEvent, MenuTextStyle,
+        Painter, Suggestion, UndoBehavior,
     },
 };
 
@@ -272,7 +272,7 @@ impl DescriptionMenu {
     }
 
     fn no_records_msg(&self, use_ansi_coloring: bool) -> String {
-        let msg = "TYPE TO START SEACH";
+        let msg = "TYPE TO START SEARCH";
         if use_ansi_coloring {
             format!(
                 "{}{}{}",
@@ -372,7 +372,7 @@ impl DescriptionMenu {
         let description = self
             .get_value()
             .and_then(|suggestion| suggestion.description)
-            .unwrap_or_else(|| "".to_string())
+            .unwrap_or_default()
             .lines()
             .skip(self.skipped_rows)
             .take(self.working_details.description_rows)
@@ -459,7 +459,7 @@ impl Menu for DescriptionMenu {
     fn can_partially_complete(
         &mut self,
         _values_updated: bool,
-        _line_buffer: &mut LineBuffer,
+        _editor: &mut Editor,
         _completer: &mut dyn Completer,
     ) -> bool {
         false
@@ -481,19 +481,21 @@ impl Menu for DescriptionMenu {
     }
 
     /// Updates menu values
-    fn update_values(&mut self, line_buffer: &mut LineBuffer, completer: &mut dyn Completer) {
+    fn update_values(&mut self, editor: &mut Editor, completer: &mut dyn Completer) {
         if self.only_buffer_difference {
             if let Some(old_string) = &self.input {
-                let (start, input) = string_difference(line_buffer.get_buffer(), old_string);
+                let (start, input) = string_difference(editor.get_buffer(), old_string);
                 if !input.is_empty() {
                     self.reset_position();
                     self.values = completer.complete(input, start);
                 }
             }
         } else {
-            let trimmed_buffer = line_buffer.get_buffer().replace('\n', " ");
-            self.values =
-                completer.complete(trimmed_buffer.as_str(), line_buffer.insertion_point());
+            let trimmed_buffer = editor.get_buffer().replace('\n', " ");
+            self.values = completer.complete(
+                trimmed_buffer.as_str(),
+                editor.line_buffer().insertion_point(),
+            );
             self.reset_position();
         }
     }
@@ -502,7 +504,7 @@ impl Menu for DescriptionMenu {
     /// collected from the completer
     fn update_working_details(
         &mut self,
-        line_buffer: &mut LineBuffer,
+        editor: &mut Editor,
         completer: &mut dyn Completer,
         painter: &Painter,
     ) {
@@ -560,13 +562,13 @@ impl Menu for DescriptionMenu {
             match event {
                 MenuEvent::Activate(_) => {
                     self.reset_position();
-                    self.input = Some(line_buffer.get_buffer().to_string());
-                    self.update_values(line_buffer, completer);
+                    self.input = Some(editor.get_buffer().to_string());
+                    self.update_values(editor, completer);
                 }
                 MenuEvent::Deactivate => self.active = false,
                 MenuEvent::Edit(_) => {
                     self.reset_position();
-                    self.update_values(line_buffer, completer);
+                    self.update_values(editor, completer);
                     self.update_examples()
                 }
                 MenuEvent::NextElement => {
@@ -586,7 +588,7 @@ impl Menu for DescriptionMenu {
                         } else {
                             self.example_index = Some(self.examples.len().saturating_sub(1));
                         }
-                    } else {
+                    } else if !self.examples.is_empty() {
                         self.example_index = Some(0);
                     }
                 }
@@ -598,7 +600,7 @@ impl Menu for DescriptionMenu {
                         } else {
                             self.example_index = Some(0);
                         }
-                    } else {
+                    } else if !self.examples.is_empty() {
                         self.example_index = Some(0);
                     }
                 }
@@ -608,7 +610,7 @@ impl Menu for DescriptionMenu {
                     let description_rows = self
                         .get_value()
                         .and_then(|suggestion| suggestion.description)
-                        .unwrap_or_else(|| "".to_string())
+                        .unwrap_or_default()
                         .lines()
                         .count();
 
@@ -627,27 +629,28 @@ impl Menu for DescriptionMenu {
     }
 
     /// The buffer gets replaced in the Span location
-    fn replace_in_buffer(&self, line_buffer: &mut LineBuffer) {
+    fn replace_in_buffer(&self, editor: &mut Editor) {
         if let Some(Suggestion { value, span, .. }) = self.get_value() {
-            let start = span.start.min(line_buffer.len());
-            let end = span.end.min(line_buffer.len());
+            let start = span.start.min(editor.line_buffer().len());
+            let end = span.end.min(editor.line_buffer().len());
 
-            let string_len = if let Some(example_index) = self.example_index {
-                let example = self
-                    .examples
+            let replacement = if let Some(example_index) = self.example_index {
+                self.examples
                     .get(example_index)
-                    .expect("the example index is always checked");
-
-                line_buffer.replace(start..end, example);
-                example.len()
+                    .expect("the example index is always checked")
             } else {
-                line_buffer.replace(start..end, &value);
-                value.len()
+                &value
             };
 
-            let mut offset = line_buffer.insertion_point();
-            offset += string_len.saturating_sub(end.saturating_sub(start));
-            line_buffer.set_insertion_point(offset);
+            editor.edit_buffer(
+                |lb| {
+                    lb.replace_range(start..end, replacement);
+                    let mut offset = lb.insertion_point();
+                    offset += lb.len().saturating_sub(end.saturating_sub(start));
+                    lb.set_insertion_point(offset);
+                },
+                UndoBehavior::CreateUndoPoint,
+            );
         }
     }
 

crates/nu-cli/src/menus/help_completions.rs

@@ -1,6 +1,7 @@
 use nu_engine::documentation::get_flags_section;
 use nu_protocol::{engine::EngineState, levenshtein_distance};
 use reedline::{Completer, Suggestion};
+use std::fmt::Write;
 use std::sync::Arc;
 
 pub struct NuHelpCompleter(Arc<EngineState>);
@@ -16,9 +17,13 @@ impl NuHelpCompleter {
         //Vec<(Signature, Vec<Example>, bool, bool)> {
         let mut commands = full_commands
             .iter()
-            .filter(|(sig, _, _, _)| {
+            .filter(|(sig, _, _, _, _)| {
                 sig.name.to_lowercase().contains(&line.to_lowercase())
                     || sig.usage.to_lowercase().contains(&line.to_lowercase())
+                    || sig
+                        .search_terms
+                        .iter()
+                        .any(|term| term.to_lowercase().contains(&line.to_lowercase()))
                     || sig
                         .extra_usage
                         .to_lowercase()
@@ -26,7 +31,7 @@ impl NuHelpCompleter {
             })
             .collect::<Vec<_>>();
 
-        commands.sort_by(|(a, _, _, _), (b, _, _, _)| {
+        commands.sort_by(|(a, _, _, _, _), (b, _, _, _, _)| {
             let a_distance = levenshtein_distance(line, &a.name);
             let b_distance = levenshtein_distance(line, &b.name);
             a_distance.cmp(&b_distance)
@@ -34,7 +39,7 @@ impl NuHelpCompleter {
 
         commands
             .into_iter()
-            .map(|(sig, examples, _, _)| {
+            .map(|(sig, examples, _, _, _)| {
                 let mut long_desc = String::new();
 
                 let usage = &sig.usage;
@@ -49,7 +54,7 @@ impl NuHelpCompleter {
                     long_desc.push_str("\r\n\r\n");
                 }
 
-                long_desc.push_str(&format!("Usage:\r\n  > {}\r\n", sig.call_signature()));
+                let _ = write!(long_desc, "Usage:\r\n  > {}\r\n", sig.call_signature());
 
                 if !sig.named.is_empty() {
                     long_desc.push_str(&get_flags_section(sig))
@@ -61,27 +66,28 @@ impl NuHelpCompleter {
                 {
                     long_desc.push_str("\r\nParameters:\r\n");
                     for positional in &sig.required_positional {
-                        long_desc
-                            .push_str(&format!("  {}: {}\r\n", positional.name, positional.desc));
+                        let _ = write!(long_desc, "  {}: {}\r\n", positional.name, positional.desc);
                     }
                     for positional in &sig.optional_positional {
-                        long_desc.push_str(&format!(
+                        let _ = write!(
+                            long_desc,
                             "  (optional) {}: {}\r\n",
                             positional.name, positional.desc
-                        ));
+                        );
                     }
 
                     if let Some(rest_positional) = &sig.rest_positional {
-                        long_desc.push_str(&format!(
+                        let _ = write!(
+                            long_desc,
                             "  ...{}: {}\r\n",
                             rest_positional.name, rest_positional.desc
-                        ));
+                        );
                     }
                 }
 
                 let extra: Vec<String> = examples
                     .iter()
-                    .map(|example| example.example.to_string())
+                    .map(|example| example.example.replace('\n', "\r\n"))
                     .collect();
 
                 Suggestion {
@@ -92,6 +98,7 @@ impl NuHelpCompleter {
                         start: pos,
                         end: pos + line.len(),
                     },
+                    append_whitespace: false,
                 }
             })
             .collect()

crates/nu-cli/src/menus/menu_completions.rs

@@ -155,6 +155,7 @@ fn convert_to_suggestions(
                 description,
                 extra,
                 span,
+                append_whitespace: false,
             }]
         }
         Value::List { vals, .. } => vals
@@ -169,6 +170,7 @@ fn convert_to_suggestions(
                 start: 0,
                 end: line.len(),
             },
+            append_whitespace: false,
         }],
     }
 }

crates/nu-cli/src/nu_highlight.rs

@@ -19,10 +19,14 @@ impl Command for NuHighlight {
         "Syntax highlight the input string."
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["syntax", "color", "convert"]
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
-        stack: &mut Stack,
+        _stack: &mut Stack,
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
@@ -30,7 +34,7 @@ impl Command for NuHighlight {
 
         let ctrlc = engine_state.ctrlc.clone();
         let engine_state = engine_state.clone();
-        let config = stack.get_config()?;
+        let config = engine_state.get_config().clone();
 
         let highlighter = crate::NuHighlighter {
             engine_state,

crates/nu-cli/src/print.rs

@@ -16,11 +16,28 @@ impl Command for Print {
     fn signature(&self) -> Signature {
         Signature::build("print")
             .rest("rest", SyntaxShape::Any, "the values to print")
+            .switch(
+                "no-newline",
+                "print without inserting a newline for the line ending",
+                Some('n'),
+            )
+            .switch("stderr", "print to stderr instead of stdout", Some('e'))
             .category(Category::Strings)
     }
 
     fn usage(&self) -> &str {
-        "Prints the values given"
+        "Print the given values to stdout"
+    }
+
+    fn extra_usage(&self) -> &str {
+        r#"Unlike `echo`, this command does not return any value (`print | describe` will return "nothing").
+Since this command has no output, there is no point in piping it with other commands.
+
+`print` may be used inside blocks of code (e.g.: hooks) to display text during execution without interfering with the pipeline."#
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["display"]
     }
 
     fn run(
@@ -31,10 +48,13 @@ impl Command for Print {
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let args: Vec<Value> = call.rest(engine_state, stack, 0)?;
+        let no_newline = call.has_flag("no-newline");
+        let to_stderr = call.has_flag("stderr");
         let head = call.head;
 
         for arg in args {
-            crate::util::print_pipeline_data(arg.into_pipeline_data(), engine_state, stack)?;
+            arg.into_pipeline_data()
+                .print(engine_state, stack, no_newline, to_stderr)?;
         }
 
         Ok(PipelineData::new(head))

crates/nu-cli/src/prompt.rs

@@ -1,5 +1,6 @@
+#[cfg(windows)]
+use nu_utils::enable_vt_processing;
 use reedline::DefaultPrompt;
-
 use {
     reedline::{
         Prompt, PromptEditMode, PromptHistorySearch, PromptHistorySearchStatus, PromptViMode,
@@ -16,6 +17,7 @@ pub struct NushellPrompt {
     default_vi_insert_prompt_indicator: Option<String>,
     default_vi_normal_prompt_indicator: Option<String>,
     default_multiline_indicator: Option<String>,
+    render_right_prompt_on_last_line: bool,
 }
 
 impl Default for NushellPrompt {
@@ -33,6 +35,7 @@ impl NushellPrompt {
             default_vi_insert_prompt_indicator: None,
             default_vi_normal_prompt_indicator: None,
             default_multiline_indicator: None,
+            render_right_prompt_on_last_line: false,
         }
     }
 
@@ -40,8 +43,13 @@ impl NushellPrompt {
         self.left_prompt_string = prompt_string;
     }
 
-    pub fn update_prompt_right(&mut self, prompt_string: Option<String>) {
+    pub fn update_prompt_right(
+        &mut self,
+        prompt_string: Option<String>,
+        render_right_prompt_on_last_line: bool,
+    ) {
         self.right_prompt_string = prompt_string;
+        self.render_right_prompt_on_last_line = render_right_prompt_on_last_line;
     }
 
     pub fn update_prompt_indicator(&mut self, prompt_indicator_string: Option<String>) {
@@ -67,6 +75,7 @@ impl NushellPrompt {
         prompt_indicator_string: Option<String>,
         prompt_multiline_indicator_string: Option<String>,
         prompt_vi: (Option<String>, Option<String>),
+        render_right_prompt_on_last_line: bool,
     ) {
         let (prompt_vi_insert_string, prompt_vi_normal_string) = prompt_vi;
 
@@ -77,6 +86,8 @@ impl NushellPrompt {
 
         self.default_vi_insert_prompt_indicator = prompt_vi_insert_string;
         self.default_vi_normal_prompt_indicator = prompt_vi_normal_string;
+
+        self.render_right_prompt_on_last_line = render_right_prompt_on_last_line;
     }
 
     fn default_wrapped_custom_string(&self, str: String) -> String {
@@ -86,6 +97,11 @@ impl NushellPrompt {
 
 impl Prompt for NushellPrompt {
     fn render_prompt_left(&self) -> Cow<str> {
+        #[cfg(windows)]
+        {
+            let _ = enable_vt_processing();
+        }
+
         if let Some(prompt_string) = &self.left_prompt_string {
             prompt_string.replace('\n', "\r\n").into()
         } else {
@@ -156,4 +172,8 @@ impl Prompt for NushellPrompt {
             prefix, history_search.term
         ))
     }
+
+    fn right_prompt_on_last_line(&self) -> bool {
+        self.render_right_prompt_on_last_line
+    }
 }

crates/nu-cli/src/prompt_update.rs

@@ -15,18 +15,21 @@ 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";
+// According to Daniel Imms @Tyriar, we need to do these this way:
+// <133 A><prompt><133 B><command><133 C><command output>
+const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
+const POST_PROMPT_MARKER: &str = "\x1b]133;B\x1b\\";
 
 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 {
+            Value::Closure {
                 val: block_id,
                 captures,
                 ..
@@ -40,14 +43,37 @@ fn get_prompt_string(
                     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::Block { val: block_id, .. } => {
+                let block = engine_state.get_block(block_id);
+                // 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
+                );
+                info!(
+                    "get_prompt_string (block) {}:{}:{}",
+                    file!(),
+                    line!(),
+                    column!()
+                );
 
                 match ret_val {
                     Ok(ret_val) => Some(ret_val),
@@ -86,57 +112,39 @@ pub(crate) fn update_prompt<'prompt>(
     engine_state: &EngineState,
     stack: &Stack,
     nu_prompt: &'prompt mut NushellPrompt,
-    is_perf_true: bool,
 ) -> &'prompt dyn Prompt {
     let mut stack = stack.clone();
 
-    let left_prompt_string = get_prompt_string(
-        PROMPT_COMMAND,
-        config,
-        engine_state,
-        &mut stack,
-        is_perf_true,
-    );
+    let left_prompt_string = get_prompt_string(PROMPT_COMMAND, config, engine_state, &mut stack);
 
-    let right_prompt_string = get_prompt_string(
-        PROMPT_COMMAND_RIGHT,
-        config,
-        engine_state,
-        &mut stack,
-        is_perf_true,
-    );
+    // Now that we have the prompt string lets ansify it.
+    // <133 A><prompt><133 B><command><133 C><command output>
+    let left_prompt_string = if config.shell_integration {
+        match left_prompt_string {
+            Some(prompt_string) => Some(format!(
+                "{}{}{}",
+                PRE_PROMPT_MARKER, prompt_string, POST_PROMPT_MARKER
+            )),
+            None => left_prompt_string,
+        }
+    } else {
+        left_prompt_string
+    };
 
-    let prompt_indicator_string = get_prompt_string(
-        PROMPT_INDICATOR,
-        config,
-        engine_state,
-        &mut stack,
-        is_perf_true,
-    );
+    let right_prompt_string =
+        get_prompt_string(PROMPT_COMMAND_RIGHT, config, engine_state, &mut stack);
 
-    let prompt_multiline_string = get_prompt_string(
-        PROMPT_MULTILINE_INDICATOR,
-        config,
-        engine_state,
-        &mut stack,
-        is_perf_true,
-    );
+    let prompt_indicator_string =
+        get_prompt_string(PROMPT_INDICATOR, config, engine_state, &mut stack);
 
-    let prompt_vi_insert_string = get_prompt_string(
-        PROMPT_INDICATOR_VI_INSERT,
-        config,
-        engine_state,
-        &mut stack,
-        is_perf_true,
-    );
+    let prompt_multiline_string =
+        get_prompt_string(PROMPT_MULTILINE_INDICATOR, config, engine_state, &mut stack);
 
-    let prompt_vi_normal_string = get_prompt_string(
-        PROMPT_INDICATOR_VI_NORMAL,
-        config,
-        engine_state,
-        &mut stack,
-        is_perf_true,
-    );
+    let prompt_vi_insert_string =
+        get_prompt_string(PROMPT_INDICATOR_VI_INSERT, config, engine_state, &mut stack);
+
+    let prompt_vi_normal_string =
+        get_prompt_string(PROMPT_INDICATOR_VI_NORMAL, config, engine_state, &mut stack);
 
     // apply the other indicators
     nu_prompt.update_all_prompt_strings(
@@ -145,12 +153,11 @@ pub(crate) fn update_prompt<'prompt>(
         prompt_indicator_string,
         prompt_multiline_string,
         (prompt_vi_insert_string, prompt_vi_normal_string),
+        config.render_right_prompt_on_last_line,
     );
 
     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

@@ -114,7 +114,7 @@ pub(crate) fn add_menus(
             let res = eval_block(&engine_state, &mut temp_stack, &block, input, false, false)?;
 
             if let PipelineData::Value(value, None) = res {
-                for menu in create_menus(&value, config)? {
+                for menu in create_menus(&value)? {
                     line_editor =
                         add_menu(line_editor, &menu, engine_state.clone(), stack, config)?;
                 }
@@ -251,7 +251,7 @@ pub(crate) fn add_columnar_menu(
         Value::Nothing { .. } => {
             Ok(line_editor.with_menu(ReedlineMenu::EngineCompleter(Box::new(columnar_menu))))
         }
-        Value::Block {
+        Value::Closure {
             val,
             captures,
             span,
@@ -337,7 +337,7 @@ pub(crate) fn add_list_menu(
         Value::Nothing { .. } => {
             Ok(line_editor.with_menu(ReedlineMenu::HistoryMenu(Box::new(list_menu))))
         }
-        Value::Block {
+        Value::Closure {
             val,
             captures,
             span,
@@ -459,7 +459,7 @@ pub(crate) fn add_description_menu(
                 completer,
             }))
         }
-        Value::Block {
+        Value::Closure {
             val,
             captures,
             span,
@@ -477,7 +477,7 @@ pub(crate) fn add_description_menu(
             }))
         }
         _ => Err(ShellError::UnsupportedConfigValue(
-            "block or omitted value".to_string(),
+            "closure or omitted value".to_string(),
             menu.source.into_abbreviated_string(config),
             menu.source.span()?,
         )),
@@ -491,7 +491,7 @@ fn add_menu_keybindings(keybindings: &mut Keybindings) {
         KeyCode::Tab,
         ReedlineEvent::UntilFound(vec![
             ReedlineEvent::Menu("completion_menu".to_string()),
-            ReedlineEvent::MenuNext,
+            ReedlineEvent::Edit(vec![EditCommand::Complete]),
         ]),
     );
 
@@ -501,14 +501,16 @@ fn add_menu_keybindings(keybindings: &mut Keybindings) {
         ReedlineEvent::MenuPrevious,
     );
 
-    // History menu keybinding
+    keybindings.add_binding(
+        KeyModifiers::CONTROL,
+        KeyCode::Char('r'),
+        ReedlineEvent::Menu("history_menu".to_string()),
+    );
+
     keybindings.add_binding(
         KeyModifiers::CONTROL,
         KeyCode::Char('x'),
-        ReedlineEvent::UntilFound(vec![
-            ReedlineEvent::Menu("history_menu".to_string()),
         ReedlineEvent::MenuPageNext,
-        ]),
     );
 
     keybindings.add_binding(
@@ -522,8 +524,8 @@ fn add_menu_keybindings(keybindings: &mut Keybindings) {
 
     // Help menu keybinding
     keybindings.add_binding(
-        KeyModifiers::CONTROL,
-        KeyCode::Char('q'),
+        KeyModifiers::NONE,
+        KeyCode::F(1),
         ReedlineEvent::Menu("help_menu".to_string()),
     );
 }
@@ -664,6 +666,7 @@ fn add_parsed_keybinding(
 
             KeyCode::Char(char)
         }
+        "space" => KeyCode::Char(' '),
         "down" => KeyCode::Down,
         "up" => KeyCode::Up,
         "left" => KeyCode::Left,
@@ -812,13 +815,15 @@ fn event_from_record(
 ) -> Result<ReedlineEvent, ShellError> {
     let event = match name {
         "none" => ReedlineEvent::None,
-        "actionhandler" => ReedlineEvent::ActionHandler,
         "clearscreen" => ReedlineEvent::ClearScreen,
+        "clearscrollback" => ReedlineEvent::ClearScrollback,
         "historyhintcomplete" => ReedlineEvent::HistoryHintComplete,
         "historyhintwordcomplete" => ReedlineEvent::HistoryHintWordComplete,
         "ctrld" => ReedlineEvent::CtrlD,
         "ctrlc" => ReedlineEvent::CtrlC,
         "enter" => ReedlineEvent::Enter,
+        "submit" => ReedlineEvent::Submit,
+        "submitornewline" => ReedlineEvent::SubmitOrNewline,
         "esc" | "escape" => ReedlineEvent::Esc,
         "up" => ReedlineEvent::Up,
         "down" => ReedlineEvent::Down,
@@ -836,6 +841,7 @@ fn event_from_record(
         "menuprevious" => ReedlineEvent::MenuPrevious,
         "menupagenext" => ReedlineEvent::MenuPageNext,
         "menupageprevious" => ReedlineEvent::MenuPagePrevious,
+        "openeditor" => ReedlineEvent::OpenEditor,
         "menu" => {
             let menu = extract_value("name", cols, vals, span)?;
             ReedlineEvent::Menu(menu.into_string("", config))
@@ -871,7 +877,16 @@ fn edit_from_record(
         "moveleft" => EditCommand::MoveLeft,
         "moveright" => EditCommand::MoveRight,
         "movewordleft" => EditCommand::MoveWordLeft,
+        "movebigwordleft" => EditCommand::MoveBigWordLeft,
         "movewordright" => EditCommand::MoveWordRight,
+        "movewordrightend" => EditCommand::MoveWordRightEnd,
+        "movebigwordrightend" => EditCommand::MoveBigWordRightEnd,
+        "movewordrightstart" => EditCommand::MoveWordRightStart,
+        "movebigwordrightstart" => EditCommand::MoveBigWordRightStart,
+        "movetoposition" => {
+            let value = extract_value("value", cols, vals, span)?;
+            EditCommand::MoveToPosition(value.as_integer()? as usize)
+        }
         "insertchar" => {
             let value = extract_value("value", cols, vals, span)?;
             let char = extract_char(value, config)?;
@@ -881,8 +896,10 @@ fn edit_from_record(
             let value = extract_value("value", cols, vals, span)?;
             EditCommand::InsertString(value.into_string("", config))
         }
+        "insertnewline" => EditCommand::InsertNewline,
         "backspace" => EditCommand::Backspace,
         "delete" => EditCommand::Delete,
+        "cutchar" => EditCommand::CutChar,
         "backspaceword" => EditCommand::BackspaceWord,
         "deleteword" => EditCommand::DeleteWord,
         "clear" => EditCommand::Clear,
@@ -893,7 +910,11 @@ fn edit_from_record(
         "cuttoend" => EditCommand::CutToEnd,
         "cuttolineend" => EditCommand::CutToLineEnd,
         "cutwordleft" => EditCommand::CutWordLeft,
+        "cutbigwordleft" => EditCommand::CutBigWordLeft,
         "cutwordright" => EditCommand::CutWordRight,
+        "cutbigwordright" => EditCommand::CutBigWordRight,
+        "cutwordrighttonext" => EditCommand::CutWordRightToNext,
+        "cutbigwordrighttonext" => EditCommand::CutBigWordRightToNext,
         "pastecutbufferbefore" => EditCommand::PasteCutBufferBefore,
         "pastecutbufferafter" => EditCommand::PasteCutBufferAfter,
         "uppercaseword" => EditCommand::UppercaseWord,
@@ -943,6 +964,7 @@ fn edit_from_record(
             let char = extract_char(value, config)?;
             EditCommand::MoveLeftBefore(char)
         }
+        "complete" => EditCommand::Complete,
         e => {
             return Err(ShellError::UnsupportedConfigValue(
                 "reedline EditCommand".to_string(),

crates/nu-cli/src/syntax_highlight.rs

@@ -1,9 +1,10 @@
 use log::trace;
 use nu_ansi_term::Style;
-use nu_color_config::get_shape_color;
+use nu_color_config::{get_matching_brackets_style, get_shape_color};
 use nu_parser::{flatten_block, parse, FlatShape};
+use nu_protocol::ast::{Argument, Block, Expr, Expression, PipelineElement};
 use nu_protocol::engine::{EngineState, StateWorkingSet};
-use nu_protocol::Config;
+use nu_protocol::{Config, Span};
 use reedline::{Highlighter, StyledText};
 
 pub struct NuHighlighter {
@@ -15,10 +16,12 @@ 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 = {
             let (block, _) = parse(&mut working_set, None, line.as_bytes(), false, &[]);
-
+            block
+        };
+        let (shapes, global_span_offset) = {
             let shapes = flatten_block(&working_set, &block);
             (shapes, self.engine_state.next_span_start())
         };
@@ -26,6 +29,15 @@ impl Highlighter for NuHighlighter {
         let mut output = StyledText::default();
         let mut last_seen_span = global_span_offset;
 
+        let global_cursor_offset = _cursor + global_span_offset;
+        let matching_brackets_pos = find_matching_brackets(
+            line,
+            &working_set,
+            &block,
+            global_span_offset,
+            global_cursor_offset,
+        );
+
         for shape in &shapes {
             if shape.0.end <= last_seen_span
                 || last_seen_span < global_span_offset
@@ -44,161 +56,75 @@ impl Highlighter for NuHighlighter {
             let next_token = line
                 [(shape.0.start - global_span_offset)..(shape.0.end - global_span_offset)]
                 .to_string();
+
+            macro_rules! add_colored_token_with_bracket_highlight {
+                ($shape:expr, $span:expr, $text:expr) => {{
+                    let spans = split_span_by_highlight_positions(
+                        line,
+                        &$span,
+                        &matching_brackets_pos,
+                        global_span_offset,
+                    );
+                    spans.iter().for_each(|(part, highlight)| {
+                        let start = part.start - $span.start;
+                        let end = part.end - $span.start;
+                        let text = (&next_token[start..end]).to_string();
+                        let mut style = get_shape_color($shape.to_string(), &self.config);
+                        if *highlight {
+                            style = get_matching_brackets_style(style, &self.config);
+                        }
+                        output.push((style, text));
+                    });
+                }};
+            }
+
+            macro_rules! add_colored_token {
+                ($shape:expr, $text:expr) => {
+                    output.push((get_shape_color($shape.to_string(), &self.config), $text))
+                };
+            }
+
             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::Garbage => add_colored_token!(shape.1, next_token),
+                FlatShape::Nothing => add_colored_token!(shape.1, next_token),
+                FlatShape::Binary => add_colored_token!(shape.1, next_token),
+                FlatShape::Bool => add_colored_token!(shape.1, next_token),
+                FlatShape::Int => add_colored_token!(shape.1, next_token),
+                FlatShape::Float => add_colored_token!(shape.1, next_token),
+                FlatShape::Range => add_colored_token!(shape.1, next_token),
+                FlatShape::InternalCall => add_colored_token!(shape.1, next_token),
+                FlatShape::External => add_colored_token!(shape.1, next_token),
+                FlatShape::ExternalArg => add_colored_token!(shape.1, next_token),
+                FlatShape::Literal => add_colored_token!(shape.1, next_token),
+                FlatShape::Operator => add_colored_token!(shape.1, next_token),
+                FlatShape::Signature => add_colored_token!(shape.1, next_token),
+                FlatShape::String => add_colored_token!(shape.1, next_token),
+                FlatShape::StringInterpolation => add_colored_token!(shape.1, next_token),
+                FlatShape::DateTime => add_colored_token!(shape.1, next_token),
                 FlatShape::List => {
-                    // nushell ???
-                    output.push((
-                        get_shape_color(shape.1.to_string(), &self.config),
-                        next_token,
-                    ))
+                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
                 }
                 FlatShape::Table => {
-                    // nushell ???
-                    output.push((
-                        get_shape_color(shape.1.to_string(), &self.config),
-                        next_token,
-                    ))
+                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
                 }
                 FlatShape::Record => {
-                    // nushell ???
-                    output.push((
-                        get_shape_color(shape.1.to_string(), &self.config),
-                        next_token,
-                    ))
+                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
                 }
+
                 FlatShape::Block => {
-                    // nushell ???
-                    output.push((
-                        get_shape_color(shape.1.to_string(), &self.config),
-                        next_token,
-                    ))
+                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, 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,
-                )),
+
+                FlatShape::Filepath => add_colored_token!(shape.1, next_token),
+                FlatShape::Directory => add_colored_token!(shape.1, next_token),
+                FlatShape::GlobPattern => add_colored_token!(shape.1, next_token),
+                FlatShape::Variable => add_colored_token!(shape.1, next_token),
+                FlatShape::Flag => add_colored_token!(shape.1, next_token),
+                FlatShape::Pipe => add_colored_token!(shape.1, next_token),
+                FlatShape::And => add_colored_token!(shape.1, next_token),
+                FlatShape::Or => add_colored_token!(shape.1, next_token),
+                FlatShape::Redirection => add_colored_token!(shape.1, next_token),
+                FlatShape::Custom(..) => add_colored_token!(shape.1, next_token),
             }
             last_seen_span = shape.0.end;
         }
@@ -211,3 +137,305 @@ impl Highlighter for NuHighlighter {
         output
     }
 }
+
+fn split_span_by_highlight_positions(
+    line: &str,
+    span: &Span,
+    highlight_positions: &Vec<usize>,
+    global_span_offset: usize,
+) -> Vec<(Span, bool)> {
+    let mut start = span.start;
+    let mut result: Vec<(Span, bool)> = Vec::new();
+    for pos in highlight_positions {
+        if start <= *pos && pos < &span.end {
+            if start < *pos {
+                result.push((Span { start, end: *pos }, false));
+            }
+            let span_str = &line[pos - global_span_offset..span.end - global_span_offset];
+            let end = span_str
+                .chars()
+                .next()
+                .map(|c| pos + get_char_length(c))
+                .unwrap_or(pos + 1);
+            result.push((Span { start: *pos, end }, true));
+            start = end;
+        }
+    }
+    if start < span.end {
+        result.push((
+            Span {
+                start,
+                end: span.end,
+            },
+            false,
+        ));
+    }
+    result
+}
+
+fn find_matching_brackets(
+    line: &str,
+    working_set: &StateWorkingSet,
+    block: &Block,
+    global_span_offset: usize,
+    global_cursor_offset: usize,
+) -> Vec<usize> {
+    const BRACKETS: &str = "{}[]()";
+
+    // calculate first bracket position
+    let global_end_offset = line.len() + global_span_offset;
+    let global_bracket_pos =
+        if global_cursor_offset == global_end_offset && global_end_offset > global_span_offset {
+            // cursor is at the end of a non-empty string -- find block end at the previous position
+            if let Some(last_char) = line.chars().last() {
+                global_cursor_offset - get_char_length(last_char)
+            } else {
+                global_cursor_offset
+            }
+        } else {
+            // cursor is in the middle of a string -- find block end at the current position
+            global_cursor_offset
+        };
+
+    // check that position contains bracket
+    let match_idx = global_bracket_pos - global_span_offset;
+    if match_idx >= line.len()
+        || !BRACKETS.contains(get_char_at_index(line, match_idx).unwrap_or_default())
+    {
+        return Vec::new();
+    }
+
+    // find matching bracket by finding matching block end
+    let matching_block_end = find_matching_block_end_in_block(
+        line,
+        working_set,
+        block,
+        global_span_offset,
+        global_bracket_pos,
+    );
+    if let Some(pos) = matching_block_end {
+        let matching_idx = pos - global_span_offset;
+        if BRACKETS.contains(get_char_at_index(line, matching_idx).unwrap_or_default()) {
+            return if global_bracket_pos < pos {
+                vec![global_bracket_pos, pos]
+            } else {
+                vec![pos, global_bracket_pos]
+            };
+        }
+    }
+    Vec::new()
+}
+
+fn find_matching_block_end_in_block(
+    line: &str,
+    working_set: &StateWorkingSet,
+    block: &Block,
+    global_span_offset: usize,
+    global_cursor_offset: usize,
+) -> Option<usize> {
+    for p in &block.pipelines {
+        for e in &p.elements {
+            match e {
+                PipelineElement::Expression(_, e)
+                | PipelineElement::Redirection(_, _, e)
+                | PipelineElement::And(_, e)
+                | PipelineElement::Or(_, e) => {
+                    if e.span.contains(global_cursor_offset) {
+                        if let Some(pos) = find_matching_block_end_in_expr(
+                            line,
+                            working_set,
+                            e,
+                            global_span_offset,
+                            global_cursor_offset,
+                        ) {
+                            return Some(pos);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
+fn find_matching_block_end_in_expr(
+    line: &str,
+    working_set: &StateWorkingSet,
+    expression: &Expression,
+    global_span_offset: usize,
+    global_cursor_offset: usize,
+) -> Option<usize> {
+    macro_rules! find_in_expr_or_continue {
+        ($inner_expr:ident) => {
+            if let Some(pos) = find_matching_block_end_in_expr(
+                line,
+                working_set,
+                $inner_expr,
+                global_span_offset,
+                global_cursor_offset,
+            ) {
+                return Some(pos);
+            }
+        };
+    }
+
+    if expression.span.contains(global_cursor_offset) && expression.span.start >= global_span_offset
+    {
+        let expr_first = expression.span.start;
+        let span_str = &line
+            [expression.span.start - global_span_offset..expression.span.end - global_span_offset];
+        let expr_last = span_str
+            .chars()
+            .last()
+            .map(|c| expression.span.end - get_char_length(c))
+            .unwrap_or(expression.span.start);
+
+        return match &expression.expr {
+            Expr::Bool(_) => None,
+            Expr::Int(_) => None,
+            Expr::Float(_) => None,
+            Expr::Binary(_) => None,
+            Expr::Range(..) => None,
+            Expr::Var(_) => None,
+            Expr::VarDecl(_) => None,
+            Expr::ExternalCall(..) => None,
+            Expr::Operator(_) => None,
+            Expr::UnaryNot(_) => None,
+            Expr::Keyword(..) => None,
+            Expr::ValueWithUnit(..) => None,
+            Expr::DateTime(_) => None,
+            Expr::Filepath(_) => None,
+            Expr::Directory(_) => None,
+            Expr::GlobPattern(_) => None,
+            Expr::String(_) => None,
+            Expr::CellPath(_) => None,
+            Expr::ImportPattern(_) => None,
+            Expr::Overlay(_) => None,
+            Expr::Signature(_) => None,
+            Expr::Nothing => None,
+            Expr::Garbage => None,
+
+            Expr::Table(hdr, rows) => {
+                if expr_last == global_cursor_offset {
+                    // cursor is at table end
+                    Some(expr_first)
+                } else if expr_first == global_cursor_offset {
+                    // cursor is at table start
+                    Some(expr_last)
+                } else {
+                    // cursor is inside table
+                    for inner_expr in hdr {
+                        find_in_expr_or_continue!(inner_expr);
+                    }
+                    for row in rows {
+                        for inner_expr in row {
+                            find_in_expr_or_continue!(inner_expr);
+                        }
+                    }
+                    None
+                }
+            }
+
+            Expr::Record(exprs) => {
+                if expr_last == global_cursor_offset {
+                    // cursor is at record end
+                    Some(expr_first)
+                } else if expr_first == global_cursor_offset {
+                    // cursor is at record start
+                    Some(expr_last)
+                } else {
+                    // cursor is inside record
+                    for (k, v) in exprs {
+                        find_in_expr_or_continue!(k);
+                        find_in_expr_or_continue!(v);
+                    }
+                    None
+                }
+            }
+
+            Expr::Call(call) => {
+                for arg in &call.arguments {
+                    let opt_expr = match arg {
+                        Argument::Named((_, _, opt_expr)) => opt_expr.as_ref(),
+                        Argument::Positional(inner_expr) => Some(inner_expr),
+                    };
+
+                    if let Some(inner_expr) = opt_expr {
+                        find_in_expr_or_continue!(inner_expr);
+                    }
+                }
+                None
+            }
+
+            Expr::FullCellPath(b) => find_matching_block_end_in_expr(
+                line,
+                working_set,
+                &b.head,
+                global_span_offset,
+                global_cursor_offset,
+            ),
+
+            Expr::BinaryOp(lhs, op, rhs) => {
+                find_in_expr_or_continue!(lhs);
+                find_in_expr_or_continue!(op);
+                find_in_expr_or_continue!(rhs);
+                None
+            }
+
+            Expr::Block(block_id)
+            | Expr::Closure(block_id)
+            | Expr::RowCondition(block_id)
+            | Expr::Subexpression(block_id) => {
+                if expr_last == global_cursor_offset {
+                    // cursor is at block end
+                    Some(expr_first)
+                } else if expr_first == global_cursor_offset {
+                    // cursor is at block start
+                    Some(expr_last)
+                } else {
+                    // cursor is inside block
+                    let nested_block = working_set.get_block(*block_id);
+                    find_matching_block_end_in_block(
+                        line,
+                        working_set,
+                        nested_block,
+                        global_span_offset,
+                        global_cursor_offset,
+                    )
+                }
+            }
+
+            Expr::StringInterpolation(inner_expr) => {
+                for inner_expr in inner_expr {
+                    find_in_expr_or_continue!(inner_expr);
+                }
+                None
+            }
+
+            Expr::List(inner_expr) => {
+                if expr_last == global_cursor_offset {
+                    // cursor is at list end
+                    Some(expr_first)
+                } else if expr_first == global_cursor_offset {
+                    // cursor is at list start
+                    Some(expr_last)
+                } else {
+                    // cursor is inside list
+                    for inner_expr in inner_expr {
+                        find_in_expr_or_continue!(inner_expr);
+                    }
+                    None
+                }
+            }
+        };
+    }
+    None
+}
+
+fn get_char_at_index(s: &str, index: usize) -> Option<char> {
+    s[index..].chars().next()
+}
+
+fn get_char_length(c: char) -> usize {
+    c.to_string().len()
+}

crates/nu-cli/src/util.rs

@@ -1,151 +1,92 @@
-use crate::CliError;
-use log::trace;
+use crate::repl::eval_hook;
 use nu_engine::eval_block;
-use nu_parser::{lex, parse, trim_quotes, Token, TokenContents};
+use nu_parser::{escape_quote_string, lex, parse, unescape_unquote_string, Token, TokenContents};
 use nu_protocol::engine::StateWorkingSet;
+use nu_protocol::CliError;
 use nu_protocol::{
-    ast::Call,
     engine::{EngineState, Stack},
-    PipelineData, ShellError, Span, Value,
+    print_if_stream, 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(())
-}
+use std::path::{Path, PathBuf};
 
 // 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) {
+//
+// The "PWD" env value will be forced to `init_cwd`.
+// The reason to use `init_cwd`:
+//
+// While gathering parent env vars, the parent `PWD` may not be the same as `current working directory`.
+// Consider to the following command as the case (assume we execute command inside `/tmp`):
+//
+//     tmux split-window -v -c "#{pane_current_path}"
+//
+// Here nu execute external command `tmux`, and tmux starts a new `nushell`, with `init_cwd` value "#{pane_current_path}".
+// But at the same time `PWD` still remains to be `/tmp`.
+//
+// In this scenario, the new `nushell`'s PWD should be "#{pane_current_path}" rather init_cwd.
+pub fn gather_parent_env_vars(engine_state: &mut EngineState, init_cwd: &Path) {
+    gather_env_vars(std::env::vars(), engine_state, init_cwd);
+}
+
+fn gather_env_vars(
+    vars: impl Iterator<Item = (String, String)>,
+    engine_state: &mut EngineState,
+    init_cwd: &Path,
+) {
     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(
+            &ShellError::GenericError(
                 format!("Environment variable was not captured: {}", env_str),
-                msg.into(),
+                "".to_string(),
+                None,
+                Some(msg.into()),
+                Vec::new(),
             ),
         );
     }
 
     fn put_env_to_fake_file(name: &str, val: &str, fake_env_file: &mut String) {
-        fake_env_file.push('`');
-        fake_env_file.push_str(name);
-        fake_env_file.push('`');
+        fake_env_file.push_str(&escape_quote_string(name));
         fake_env_file.push('=');
-        fake_env_file.push('`');
-        fake_env_file.push_str(val);
-        fake_env_file.push('`');
+        fake_env_file.push_str(&escape_quote_string(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);
+    // Write all the env vars into a fake file
+    for (name, val) in vars {
+        put_env_to_fake_file(&name, &val, &mut fake_env_file);
     }
-            Err(e) => {
+
+    match init_cwd.to_str() {
+        Some(cwd) => {
+            put_env_to_fake_file("PWD", cwd, &mut fake_env_file);
+        }
+        None => {
             // 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),
+                &ShellError::GenericError(
+                    "Current directory is not a valid utf-8 path".to_string(),
+                    "".to_string(),
+                    None,
+                    Some(format!(
+                        "Retrieving current directory failed: {:?} not a valid utf-8 path",
+                        init_cwd
+                    )),
+                    Vec::new(),
                 ),
             );
         }
     }
-    }
-
-    // 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);
-    }
 
     // Lex the fake file, assign spans to all environment variables and add them
     // to stack
@@ -184,8 +125,19 @@ pub fn gather_parent_env_vars(engine_state: &mut EngineState) {
                     continue;
                 }
 
-                let bytes = trim_quotes(bytes);
-                String::from_utf8_lossy(bytes).to_string()
+                let (bytes, parse_error) = unescape_unquote_string(bytes, *span);
+
+                if parse_error.is_some() {
+                    report_capture_error(
+                        engine_state,
+                        &String::from_utf8_lossy(contents),
+                        "Got unparsable name.",
+                    );
+
+                    continue;
+                }
+
+                bytes
             } else {
                 report_capture_error(
                     engine_state,
@@ -213,10 +165,20 @@ pub fn gather_parent_env_vars(engine_state: &mut EngineState) {
                     continue;
                 }
 
-                let bytes = trim_quotes(bytes);
+                let (bytes, parse_error) = unescape_unquote_string(bytes, *span);
+
+                if parse_error.is_some() {
+                    report_capture_error(
+                        engine_state,
+                        &String::from_utf8_lossy(contents),
+                        "Got unparsable value.",
+                    );
+
+                    continue;
+                }
 
                 Value::String {
-                    val: String::from_utf8_lossy(bytes).to_string(),
+                    val: bytes,
                     span: *span,
                 }
             } else {
@@ -230,7 +192,7 @@ pub fn gather_parent_env_vars(engine_state: &mut EngineState) {
             };
 
             // stack.add_env_var(name, value);
-            engine_state.env_vars.insert(name, value);
+            engine_state.add_env_var(name, value);
         }
     }
 }
@@ -242,8 +204,6 @@ pub fn eval_source(
     fname: &str,
     input: PipelineData,
 ) -> bool {
-    trace!("eval_source");
-
     let (block, delta) = {
         let mut working_set = StateWorkingSet::new(engine_state);
         let (output, err) = parse(
@@ -262,39 +222,49 @@ pub fn eval_source(
         (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);
+    if let Err(err) = engine_state.merge_delta(delta) {
+        set_last_exit_code(stack, 1);
+        report_error_new(engine_state, &err);
+        return false;
     }
 
     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 {
-                    set_last_exit_code(stack, 0);
+        Ok(pipeline_data) => {
+            let config = engine_state.get_config();
+            let result;
+            if let PipelineData::ExternalStream {
+                stdout: stream,
+                stderr: stderr_stream,
+                exit_code,
+                ..
+            } = pipeline_data
+            {
+                result = print_if_stream(stream, stderr_stream, false, exit_code);
+            } else if let Some(hook) = config.hooks.display_output.clone() {
+                match eval_hook(engine_state, stack, Some(pipeline_data), vec![], &hook) {
+                    Err(err) => {
+                        result = Err(err);
+                    }
+                    Ok(val) => {
+                        result = val.print(engine_state, stack, false, false);
+                    }
                 }
             } else {
-                set_last_exit_code(stack, 0);
+                result = pipeline_data.print(engine_state, stack, false, false);
             }
 
-            if let Err(err) = print_pipeline_data(pipeline_data, engine_state, stack) {
+            match result {
+                Err(err) => {
                     let working_set = StateWorkingSet::new(engine_state);
 
                     report_error(&working_set, &err);
 
                     return false;
                 }
+                Ok(exit_code) => {
+                    set_last_exit_code(stack, exit_code);
+                }
+            }
 
             // reset vt processing, aka ansi because illbehaved externals can break it
             #[cfg(windows)]
@@ -338,6 +308,15 @@ pub fn report_error(
     }
 }
 
+pub fn report_error_new(
+    engine_state: &EngineState,
+    error: &(dyn miette::Diagnostic + Send + Sync + 'static),
+) {
+    let working_set = StateWorkingSet::new(engine_state);
+
+    report_error(&working_set, error);
+}
+
 pub fn get_init_cwd() -> PathBuf {
     match std::env::current_dir() {
         Ok(cwd) => cwd,
@@ -350,3 +329,50 @@ pub fn get_init_cwd() -> PathBuf {
         },
     }
 }
+
+pub fn get_guaranteed_cwd(engine_state: &EngineState, stack: &Stack) -> PathBuf {
+    match nu_engine::env::current_dir(engine_state, stack) {
+        Ok(p) => p,
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
+            get_init_cwd()
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_gather_env_vars() {
+        let mut engine_state = EngineState::new();
+        let symbols = r##" !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"##;
+
+        gather_env_vars(
+            [
+                ("FOO".into(), "foo".into()),
+                ("SYMBOLS".into(), symbols.into()),
+                (symbols.into(), "symbols".into()),
+            ]
+            .into_iter(),
+            &mut engine_state,
+            Path::new("t"),
+        );
+
+        let env = engine_state.render_env_vars();
+
+        assert!(
+            matches!(env.get(&"FOO".to_string()), Some(&Value::String { val, .. }) if val == "foo")
+        );
+        assert!(
+            matches!(env.get(&"SYMBOLS".to_string()), Some(&Value::String { val, .. }) if val == symbols)
+        );
+        assert!(
+            matches!(env.get(&symbols.to_string()), Some(&Value::String { val, .. }) if val == "symbols")
+        );
+        assert!(env.get(&"PWD".to_string()).is_some());
+        assert_eq!(env.len(), 4);
+    }
+}

crates/nu-cli/tests/completions.rs

@@ -0,0 +1,734 @@
+pub mod support;
+
+use nu_cli::NuCompleter;
+use nu_parser::parse;
+use nu_protocol::engine::StateWorkingSet;
+use reedline::{Completer, Suggestion};
+use rstest::{fixture, rstest};
+use support::{file, folder, match_suggestions, new_engine};
+
+#[fixture]
+fn completer() -> NuCompleter {
+    // Create a new engine
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Add record value as example
+    let record = "def tst [--mod -s] {}";
+    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    // Instantiate a new completer
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
+}
+
+#[fixture]
+fn completer_strings() -> NuCompleter {
+    // Create a new engine
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Add record value as example
+    let record = r#"def animals [] { ["cat", "dog", "eel" ] }
+    def my-command [animal: string@animals] { print $animal }"#;
+    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    // Instantiate a new completer
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
+}
+
+#[test]
+fn variables_dollar_sign_with_varialblecompletion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "$ ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    assert_eq!(7, suggestions.len());
+}
+
+#[rstest]
+fn variables_double_dash_argument_with_flagcompletion(mut completer: NuCompleter) {
+    let suggestions = completer.complete("tst --", 6);
+    let expected: Vec<String> = vec!["--help".into(), "--mod".into()];
+    // dbg!(&expected, &suggestions);
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_single_dash_argument_with_flagcompletion(mut completer: NuCompleter) {
+    let suggestions = completer.complete("tst -", 5);
+    let expected: Vec<String> = vec!["--help".into(), "--mod".into(), "-h".into(), "-s".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_command_with_commandcompletion(mut completer_strings: NuCompleter) {
+    let suggestions = completer_strings.complete("my-c ", 4);
+    let expected: Vec<String> = vec!["my-command".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_subcommands_with_customcompletion(mut completer_strings: NuCompleter) {
+    let suggestions = completer_strings.complete("my-command ", 11);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_customcompletion_subcommands_with_customcompletion_2(
+    mut completer_strings: NuCompleter,
+) {
+    let suggestions = completer_strings.complete("my-command ", 11);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[test]
+fn dotnu_completions() {
+    // Create a new engine
+    let (_, _, engine, stack) = new_engine();
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    // Test source completion
+    let completion_str = "source-env ".to_string();
+    let suggestions = completer.complete(&completion_str, completion_str.len());
+
+    assert_eq!(1, suggestions.len());
+    assert_eq!("custom_completion.nu", suggestions.get(0).unwrap().value);
+
+    // Test use completion
+    let completion_str = "use ".to_string();
+    let suggestions = completer.complete(&completion_str, completion_str.len());
+
+    assert_eq!(1, suggestions.len());
+    assert_eq!("custom_completion.nu", suggestions.get(0).unwrap().value);
+}
+
+#[test]
+#[ignore]
+fn external_completer_trailing_space() {
+    // https://github.com/nushell/nushell/issues/6378
+    let block = "let external_completer = {|spans| $spans}";
+    let input = "gh alias ".to_string();
+
+    let suggestions = run_external_completion(block, &input);
+    assert_eq!(3, suggestions.len());
+    assert_eq!("gh", suggestions.get(0).unwrap().value);
+    assert_eq!("alias", suggestions.get(1).unwrap().value);
+    assert_eq!("", suggestions.get(2).unwrap().value);
+}
+
+#[test]
+fn external_completer_no_trailing_space() {
+    let block = "let external_completer = {|spans| $spans}";
+    let input = "gh alias".to_string();
+
+    let suggestions = run_external_completion(block, &input);
+    assert_eq!(2, suggestions.len());
+    assert_eq!("gh", suggestions.get(0).unwrap().value);
+    assert_eq!("alias", suggestions.get(1).unwrap().value);
+}
+
+#[test]
+fn external_completer_pass_flags() {
+    let block = "let external_completer = {|spans| $spans}";
+    let input = "gh api --".to_string();
+
+    let suggestions = run_external_completion(block, &input);
+    assert_eq!(3, suggestions.len());
+    assert_eq!("gh", suggestions.get(0).unwrap().value);
+    assert_eq!("api", suggestions.get(1).unwrap().value);
+    assert_eq!("--", suggestions.get(2).unwrap().value);
+}
+
+#[test]
+fn file_completions() {
+    // Create a new engine
+    let (dir, dir_str, engine, stack) = new_engine();
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    // Test completions for the current folder
+    let target_dir = format!("cp {}", dir_str);
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![
+        file(dir.join("nushell")),
+        folder(dir.join("test_a")),
+        folder(dir.join("test_b")),
+        folder(dir.join("another")),
+        file(dir.join("custom_completion.nu")),
+        file(dir.join(".hidden_file")),
+        folder(dir.join(".hidden_folder")),
+    ];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+
+    // Test completions for a file
+    let target_dir = format!("cp {}", folder(dir.join("another")));
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![file(dir.join("another").join("newfile"))];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+}
+
+#[test]
+fn command_ls_with_filecompletion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "ls ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+#[test]
+fn command_open_with_filecompletion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "open ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn command_rm_with_globcompletion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "rm ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn command_cp_with_globcompletion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "cp ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn command_save_with_filecompletion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "save ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn command_touch_with_filecompletion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "touch ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn command_watch_with_filecompletion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "watch ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn flag_completions() {
+    // Create a new engine
+    let (_, _, engine, stack) = new_engine();
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+    // Test completions for the 'ls' flags
+    let suggestions = completer.complete("ls -", 4);
+
+    assert_eq!(14, suggestions.len());
+
+    let expected: Vec<String> = vec![
+        "--all".into(),
+        "--directory".into(),
+        "--du".into(),
+        "--full-paths".into(),
+        "--help".into(),
+        "--long".into(),
+        "--short-names".into(),
+        "-D".into(),
+        "-a".into(),
+        "-d".into(),
+        "-f".into(),
+        "-h".into(),
+        "-l".into(),
+        "-s".into(),
+    ];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+}
+
+#[test]
+fn folder_with_directorycompletions() {
+    // Create a new engine
+    let (dir, dir_str, engine, stack) = new_engine();
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    // Test completions for the current folder
+    let target_dir = format!("cd {}", dir_str);
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![
+        folder(dir.join("test_a")),
+        folder(dir.join("test_b")),
+        folder(dir.join("another")),
+        folder(dir.join(".hidden_folder")),
+    ];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+}
+
+#[test]
+fn variables_completions() {
+    // Create a new engine
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Add record value as example
+    let record = "let actor = { name: 'Tom Hardy', age: 44 }";
+    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    // Test completions for $nu
+    let suggestions = completer.complete("$nu.", 4);
+
+    assert_eq!(9, suggestions.len());
+
+    let expected: Vec<String> = vec![
+        "config-path".into(),
+        "env-path".into(),
+        "history-path".into(),
+        "home-path".into(),
+        "loginshell-path".into(),
+        "os-info".into(),
+        "pid".into(),
+        "scope".into(),
+        "temp-path".into(),
+    ];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+
+    // Test completions for $nu.h (filter)
+    let suggestions = completer.complete("$nu.h", 5);
+
+    assert_eq!(2, suggestions.len());
+
+    let expected: Vec<String> = vec!["history-path".into(), "home-path".into()];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+
+    // Test completions for custom var
+    let suggestions = completer.complete("$actor.", 7);
+
+    assert_eq!(2, suggestions.len());
+
+    let expected: Vec<String> = vec!["age".into(), "name".into()];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+
+    // Test completions for custom var (filtering)
+    let suggestions = completer.complete("$actor.n", 8);
+
+    assert_eq!(1, suggestions.len());
+
+    let expected: Vec<String> = vec!["name".into()];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+
+    // Test completions for $env
+    let suggestions = completer.complete("$env.", 5);
+
+    assert_eq!(2, suggestions.len());
+
+    let expected: Vec<String> = vec!["PWD".into(), "TEST".into()];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+
+    // Test completions for $env
+    let suggestions = completer.complete("$env.T", 6);
+
+    assert_eq!(1, suggestions.len());
+
+    let expected: Vec<String> = vec!["TEST".into()];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+}
+
+#[test]
+fn alias_of_command_and_flags() {
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Create an alias
+    let alias = r#"alias ll = ls -l"#;
+    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let suggestions = completer.complete("ll t", 4);
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec!["test_a\\".to_string(), "test_b\\".to_string()];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec!["test_a/".to_string(), "test_b/".to_string()];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn alias_of_basic_command() {
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Create an alias
+    let alias = r#"alias ll = ls "#;
+    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let suggestions = completer.complete("ll t", 4);
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec!["test_a\\".to_string(), "test_b\\".to_string()];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec!["test_a/".to_string(), "test_b/".to_string()];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn alias_of_another_alias() {
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Create an alias
+    let alias = r#"alias ll = ls -la"#;
+    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir.clone()).is_ok());
+    // Create the second alias
+    let alias = r#"alias lf = ll -f"#;
+    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let suggestions = completer.complete("lf t", 4);
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec!["test_a\\".to_string(), "test_b\\".to_string()];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec!["test_a/".to_string(), "test_b/".to_string()];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+fn run_external_completion(block: &str, input: &str) -> Vec<Suggestion> {
+    // Create a new engine
+    let (dir, _, mut engine_state, mut stack) = new_engine();
+    let (_, delta) = {
+        let mut working_set = StateWorkingSet::new(&engine_state);
+        let (block, err) = parse(&mut working_set, None, block.as_bytes(), false, &[]);
+        assert!(err.is_none());
+
+        (block, working_set.render())
+    };
+
+    assert!(engine_state.merge_delta(delta).is_ok());
+
+    // Merge environment into the permanent state
+    assert!(engine_state.merge_env(&mut stack, &dir).is_ok());
+
+    let latest_block_id = engine_state.num_blocks() - 1;
+
+    // Change config adding the external completer
+    let mut config = engine_state.get_config().clone();
+    config.external_completer = Some(latest_block_id);
+    engine_state.set_config(&config);
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine_state), stack);
+
+    completer.complete(input, input.len())
+}
+
+#[test]
+fn unknown_command_completion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "thiscommanddoesnotexist ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[rstest]
+fn flagcompletion_triggers_after_cursor(mut completer: NuCompleter) {
+    let suggestions = completer.complete("tst -h", 5);
+    let expected: Vec<String> = vec!["--help".into(), "--mod".into(), "-h".into(), "-s".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn customcompletion_triggers_after_cursor(mut completer_strings: NuCompleter) {
+    let suggestions = completer_strings.complete("my-command c", 11);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn customcompletion_triggers_after_cursor_piped(mut completer_strings: NuCompleter) {
+    let suggestions = completer_strings.complete("my-command c | ls", 11);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn flagcompletion_triggers_after_cursor_piped(mut completer: NuCompleter) {
+    let suggestions = completer.complete("tst -h | ls", 5);
+    let expected: Vec<String> = vec!["--help".into(), "--mod".into(), "-h".into(), "-s".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[test]
+fn filecompletions_triggers_after_cursor() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let suggestions = completer.complete("cp   test_c", 3);
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions);
+}

crates/nu-cli/tests/support/completions_helpers.rs

@@ -0,0 +1,126 @@
+use std::path::PathBuf;
+
+use nu_command::create_default_context;
+use nu_engine::eval_block;
+use nu_parser::parse;
+use nu_protocol::{
+    engine::{EngineState, Stack, StateWorkingSet},
+    PipelineData, ShellError, Span, Value,
+};
+use nu_test_support::fs;
+use reedline::Suggestion;
+const SEP: char = std::path::MAIN_SEPARATOR;
+
+// creates a new engine with the current path into the completions fixtures folder
+pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
+    // Target folder inside assets
+    let dir = fs::fixtures().join("completions");
+    let mut dir_str = dir
+        .clone()
+        .into_os_string()
+        .into_string()
+        .unwrap_or_default();
+    dir_str.push(SEP);
+
+    // Create a new engine with default context
+    let mut engine_state = create_default_context();
+
+    // New stack
+    let mut stack = Stack::new();
+
+    // Add pwd as env var
+    stack.add_env_var(
+        "PWD".to_string(),
+        Value::String {
+            val: dir_str.clone(),
+            span: nu_protocol::Span {
+                start: 0,
+                end: dir_str.len(),
+            },
+        },
+    );
+    stack.add_env_var(
+        "TEST".to_string(),
+        Value::String {
+            val: "NUSHELL".to_string(),
+            span: nu_protocol::Span {
+                start: 0,
+                end: dir_str.len(),
+            },
+        },
+    );
+
+    // Merge environment into the permanent state
+    let merge_result = engine_state.merge_env(&mut stack, &dir);
+    assert!(merge_result.is_ok());
+
+    (dir, dir_str, engine_state, stack)
+}
+
+// match a list of suggestions with the expected values
+pub fn match_suggestions(expected: Vec<String>, suggestions: Vec<Suggestion>) {
+    let expected_len = expected.len();
+    let suggestions_len = suggestions.len();
+    if expected_len != suggestions_len {
+        panic!(
+            "\nexpected {expected_len} suggestions but got {suggestions_len}: \n\
+            Suggestions: {suggestions:#?} \n\
+            Expected: {expected:#?}\n"
+        )
+    }
+    expected.iter().zip(suggestions).for_each(|it| {
+        assert_eq!(it.0, &it.1.value);
+    });
+}
+
+// append the separator to the converted path
+pub fn folder(path: PathBuf) -> String {
+    let mut converted_path = file(path);
+    converted_path.push(SEP);
+
+    converted_path
+}
+
+// convert a given path to string
+pub fn file(path: PathBuf) -> String {
+    path.into_os_string().into_string().unwrap_or_default()
+}
+
+// merge_input executes the given input into the engine
+// and merges the state
+pub fn merge_input(
+    input: &[u8],
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    dir: PathBuf,
+) -> Result<(), ShellError> {
+    let (block, delta) = {
+        let mut working_set = StateWorkingSet::new(engine_state);
+
+        let (block, err) = parse(&mut working_set, None, input, false, &[]);
+
+        assert!(err.is_none());
+
+        (block, working_set.render())
+    };
+
+    engine_state.merge_delta(delta)?;
+
+    assert!(eval_block(
+        engine_state,
+        stack,
+        &block,
+        PipelineData::Value(
+            Value::Nothing {
+                span: Span { start: 0, end: 0 },
+            },
+            None
+        ),
+        false,
+        false
+    )
+    .is_ok());
+
+    // Merge environment into the permanent state
+    engine_state.merge_env(stack, &dir)
+}

crates/nu-cli/tests/support/mod.rs

@@ -0,0 +1,3 @@
+pub mod completions_helpers;
+
+pub use completions_helpers::{file, folder, match_suggestions, merge_input, new_engine};

crates/nu-color-config/Cargo.toml

@@ -1,14 +1,15 @@
 [package]
 authors = ["The Nushell Project Developers"]
 description = "Color configuration code used by Nushell"
+repository = "https://github.com/nushell/nushell/tree/main/crates/nu-color-config"
 edition = "2021"
 license = "MIT"
 name = "nu-color-config"
-version = "0.61.0"
+version = "0.72.0"
 
 [dependencies]
-nu-protocol = { path = "../nu-protocol", version = "0.61.0"  }
-nu-ansi-term = "0.45.1"
-nu-json = { path = "../nu-json", version = "0.61.0"  }
-nu-table = { path = "../nu-table", version = "0.61.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.72.0"  }
+nu-ansi-term = "0.46.0"
+nu-json = { path = "../nu-json", version = "0.72.0"  }
+nu-table = { path = "../nu-table", version = "0.72.0"  }
 serde = { version="1.0.123", features=["derive"] }

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

@@ -161,6 +161,13 @@ pub fn lookup_ansi_color_style(s: &str) -> Style {
             "dgrbl" | "dark_gray_blink" => Color::DarkGray.blink(),
             "dgrst" | "dark_gray_strike" => Color::DarkGray.strikethrough(),
 
+            "def" | "default" => Color::Default.normal(),
+            "defb" | "default_bold" => Color::Default.bold(),
+            "defu" | "default_underline" => Color::Default.underline(),
+            "defi" | "default_italic" => Color::Default.italic(),
+            "defd" | "default_dimmed" => Color::Default.dimmed(),
+            "defr" | "default_reverse" => Color::Default.reverse(),
+
             _ => Color::White.normal(),
         }
     }
@@ -210,15 +217,10 @@ pub fn get_color_config(config: &Config) -> HashMap<String, Style> {
     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]
-        // );
+        match value.as_string() {
+            Ok(value) => update_hashmap(key, &value, &mut hm),
+            Err(_) => continue,
+        }
     }
 
     hm

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

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

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

@@ -0,0 +1,30 @@
+use crate::color_config::lookup_ansi_color_style;
+use nu_ansi_term::Style;
+use nu_protocol::Config;
+
+pub fn get_matching_brackets_style(default_style: Style, conf: &Config) -> Style {
+    const MATCHING_BRACKETS_CONFIG_KEY: &str = "shape_matching_brackets";
+
+    match conf.color_config.get(MATCHING_BRACKETS_CONFIG_KEY) {
+        Some(int_color) => match int_color.as_string() {
+            Ok(int_color) => merge_styles(default_style, lookup_ansi_color_style(&int_color)),
+            Err(_) => default_style,
+        },
+        None => default_style,
+    }
+}
+
+fn merge_styles(base: Style, extra: Style) -> Style {
+    Style {
+        foreground: extra.foreground.or(base.foreground),
+        background: extra.background.or(base.background),
+        is_bold: extra.is_bold || base.is_bold,
+        is_dimmed: extra.is_dimmed || base.is_dimmed,
+        is_italic: extra.is_italic || base.is_italic,
+        is_underline: extra.is_underline || base.is_underline,
+        is_blink: extra.is_blink || base.is_blink,
+        is_reverse: extra.is_reverse || base.is_reverse,
+        is_hidden: extra.is_hidden || base.is_hidden,
+        is_strikethrough: extra.is_strikethrough || base.is_strikethrough,
+    }
+}

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

@@ -1,7 +1,7 @@
 use nu_ansi_term::{Color, Style};
 use serde::Deserialize;
 
-#[derive(Deserialize, PartialEq, Debug)]
+#[derive(Deserialize, PartialEq, Eq, Debug)]
 pub struct NuStyle {
     pub fg: Option<String>,
     pub bg: Option<String>,
@@ -11,12 +11,12 @@ pub struct NuStyle {
 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"),
+        Some(fg) => color_from_hex(&fg).unwrap_or_default(),
         _ => 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"),
+        Some(bg) => color_from_hex(&bg).unwrap_or_default(),
         _ => None,
     };
     // get the attributes

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

@@ -29,10 +29,15 @@ pub fn get_shape_color(shape: String, conf: &Config) -> Style {
             "shape_record" => Style::new().fg(Color::Cyan).bold(),
             "shape_block" => Style::new().fg(Color::Blue).bold(),
             "shape_filepath" => Style::new().fg(Color::Cyan),
+            "shape_directory" => 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_pipe" => Style::new().fg(Color::Purple).bold(),
+            "shape_redirection" => Style::new().fg(Color::Purple).bold(),
+            "shape_and" => Style::new().fg(Color::Purple).bold(),
+            "shape_or" => Style::new().fg(Color::Purple).bold(),
             "shape_nothing" => Style::new().fg(Color::LightCyan),
             _ => Style::default(),
         },

crates/nu-command/Cargo.toml

@@ -1,44 +1,48 @@
 [package]
 authors = ["The Nushell Project Developers"]
 description = "Nushell's built-in commands"
+repository = "https://github.com/nushell/nushell/tree/main/crates/nu-command"
 edition = "2021"
 license = "MIT"
 name = "nu-command"
-version = "0.61.0"
+version = "0.72.0"
 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.61.0"  }
-nu-engine = { path = "../nu-engine", version = "0.61.0"  }
-nu-glob = { path = "../nu-glob", version = "0.61.0" }
-nu-json = { path = "../nu-json", version = "0.61.0"  }
-nu-parser = { path = "../nu-parser", version = "0.61.0"  }
-nu-path = { path = "../nu-path", version = "0.61.0"  }
-nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.61.0"  }
-nu-protocol = { path = "../nu-protocol", version = "0.61.0"  }
-nu-system = { path = "../nu-system", version = "0.61.0"  }
-nu-table = { path = "../nu-table", version = "0.61.0"  }
-nu-term-grid = { path = "../nu-term-grid", version = "0.61.0"  }
-nu-test-support = { path = "../nu-test-support", version = "0.61.0"  }
-nu-utils = { path = "../nu-utils", version = "0.61.0" }
-nu-ansi-term = "0.45.1"
+nu-color-config = { path = "../nu-color-config", version = "0.72.0"  }
+nu-engine = { path = "../nu-engine", version = "0.72.0"  }
+nu-glob = { path = "../nu-glob", version = "0.72.0" }
+nu-json = { path = "../nu-json", version = "0.72.0"  }
+nu-parser = { path = "../nu-parser", version = "0.72.0"  }
+nu-path = { path = "../nu-path", version = "0.72.0"  }
+nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.72.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.72.0"  }
+nu-system = { path = "../nu-system", version = "0.72.0"  }
+nu-table = { path = "../nu-table", version = "0.72.0"  }
+nu-term-grid = { path = "../nu-term-grid", version = "0.72.0"  }
+nu-utils = { path = "../nu-utils", version = "0.72.0" }
+nu-ansi-term = "0.46.0"
+num-format = { version = "0.4.3" }
 
 # Potential dependencies for extras
+alphanumeric-sort = "1.4.4"
 base64 = "0.13.0"
+byteorder = "1.4.3"
 bytesize = "1.1.0"
 calamine = "0.18.0"
-chrono = { version = "0.4.19", features = ["serde"] }
+chrono = { version = "0.4.23", features = ["unstable-locales", "std"], default-features = false }
 chrono-humanize = "0.2.1"
-chrono-tz = "0.6.0"
-crossterm = "0.23.0"
+chrono-tz = "0.6.3"
+crossterm = "0.24.0"
 csv = "1.1.6"
-dialoguer = "0.9.0"
-digest = "0.10.0"
+dialoguer = { default-features = false, version = "0.9.0" }
+digest = { default-features = false, version = "0.10.0" }
 dtparse = "1.2.0"
 eml-parser = "0.1.0"
 encoding_rs = "0.8.30"
+fancy-regex = "0.10.0"
 filesize = "0.2.0"
 filetime = "0.2.15"
 fs_extra = "1.2.0"
@@ -46,71 +50,115 @@ htmlescape = "0.3.1"
 ical = "0.7.0"
 indexmap = { version="1.7", features=["serde-1"] }
 Inflector = "0.11"
+is-root = "0.1.2"
 itertools = "0.10.0"
 lazy_static = "1.4.0"
 log = "0.4.14"
-lscolors = { version = "0.9.0", features = ["crossterm"]}
+lscolors = { version = "0.12.0", features = ["crossterm"], default-features = false }
 md5 = { package = "md-5", version = "0.10.0" }
 meval = "0.2.0"
 mime = "0.3.16"
+notify = "4.0.17"
 num = { version = "0.4.0", optional = true }
+num-traits = "0.2.14"
+once_cell = "1.0"
 pathdiff = "0.2.1"
-quick-xml = "0.22"
+powierza-coefficient = "1.0.1"
+quick-xml = "0.23.0"
 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"
+same-file = "1.0.6"
 serde = { version="1.0.123", features=["derive"] }
 serde_ini = "0.2.0"
 serde_urlencoded = "0.7.0"
-serde_yaml = "0.8.16"
+serde_yaml = "0.9.4"
 sha2 = "0.10.0"
-shadow-rs = "0.11.0"
-strip-ansi-escapes = "0.1.1"
-sysinfo = "0.23.5"
-terminal_size = "0.1.17"
-thiserror = "1.0.29"
-titlecase = "1.1.0"
+# Disable default features b/c the default features build Git (very slow to compile)
+shadow-rs = { version = "0.16.1", default-features = false }
+sysinfo = "0.26.2"
+terminal_size = "0.2.1"
+thiserror = "1.0.31"
+titlecase = "2.0.0"
 toml = "0.5.8"
 unicode-segmentation = "1.8.0"
 url = "2.2.1"
-uuid = { version = "0.8.2", features = ["v4"] }
-which = { version = "4.2.2", optional = true }
-reedline =  { version = "0.4.0", features = ["bashisms"]}
-wax = { version =  "0.4.0", features = ["diagnostics"] }
-zip = { version="0.5.9", optional = true }
+uuid = { version = "1.1.2", features = ["v4"] }
+which = { version = "4.3.0", optional = true }
+reedline = { version = "0.14.0", features = ["bashisms", "sqlite"]}
+wax = { version =  "0.5.0" }
+rusqlite = { version = "0.28.0", features = ["bundled"], optional = true }
+sqlparser = { version = "0.23.0", features = ["serde"], optional = true }
+
+[target.'cfg(windows)'.dependencies]
+winreg = "0.10.1"
 
 [target.'cfg(unix)'.dependencies]
-umask = "1.0.0"
+umask = "2.0.0"
 users = "0.11.0"
+libc = "0.2"
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies.trash]
-version = "2.0.2"
+version = "2.1.3"
 optional = true
 
 [dependencies.polars]
-version = "0.20.0"
+version = "0.25.0"
 optional = true
 features = [
-	"default", "parquet", "json", "serde", "object",
-	"checked_arithmetic", "strings", "cum_agg", "is_in",
-	"rolling_window", "strings", "rows", "random",
-    "dtype-datetime"
+	"arg_where",
+	"checked_arithmetic",
+	"concat_str",
+	"cross_join",
+	"csv-file",
+	"cum_agg",
+	"default",
+	"dtype-datetime",
+	"dtype-struct",
+	"dtype-categorical",
+	"dynamic_groupby",
+	"ipc",
+	"is_in",
+	"json",
+	"lazy",
+	"object",
+	"parquet",
+	"random",
+	"rolling_window",
+	"rows",
+	"serde",
+	"serde-lazy",
+	"strings",
+	"strings",
+	"to_dummies",
+]
+
+[target.'cfg(windows)'.dependencies.windows]
+version = "0.42.0"
+features = [
+    "Win32_Foundation",
+    "Win32_Storage_FileSystem",
+	"Win32_System_SystemServices",
 ]
 
 [features]
 trash-support = ["trash"]
 which-support = ["which"]
 plugin = ["nu-parser/plugin"]
-dataframe = ["polars", "num"]
+dataframe = ["polars", "num", "sqlparser"]
+sqlite = ["rusqlite"] # TODO: given that rusqlite is included in reedline, should we just always include it?
 
 [build-dependencies]
-shadow-rs = "0.11.0"
+shadow-rs = { version = "0.16.1", default-features = false }
 
 [dev-dependencies]
+nu-test-support = { path = "../nu-test-support", version = "0.72.0"  }
+
 hamcrest2 = "0.3.0"
 dirs-next = "2.0.0"
+proptest = "1.0.0"
 quickcheck = "1.0.3"
 quickcheck_macros = "1.0.0"
+rstest = {version = "0.15.0", default-features = false}

crates/nu-command/build.rs

@@ -1,3 +1,20 @@
+use std::process::Command;
+
 fn main() -> shadow_rs::SdResult<()> {
+    // Look up the current Git commit ourselves instead of relying on shadow_rs,
+    // because shadow_rs does it in a really slow-to-compile way (it builds libgit2)
+    let hash = get_git_hash().unwrap_or_default();
+    println!("cargo:rustc-env=NU_COMMIT_HASH={}", hash);
+
     shadow_rs::new()
 }
+
+fn get_git_hash() -> Option<String> {
+    Command::new("git")
+        .args(["rev-parse", "HEAD"])
+        .output()
+        .ok()
+        .filter(|output| output.status.success())
+        .and_then(|output| String::from_utf8(output.stdout).ok())
+        .map(|hash| hash.trim().to_string())
+}

crates/nu-command/proptest-regressions/format_conversions/nuon.txt

@@ -0,0 +1,23 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 96a80ecd19729fb43a7b7bb2766b37d6083ba73b16abb97075875e3cfcdc763f # shrinks to c = '"'
+cc 4146602559ea717a02bcef3c6d73cdf613c30d0c3f92c48e26c79b9a1544e027 # shrinks to c = '\\'
+cc 80532a0ee73df456a719b9e3cce1ae5f3d26009dde819cbaf16f8e0cb6709705 # shrinks to c = ':'
+cc cdb88505686eea3c74c36f282fd29b2b68bc118ded4ebfc36f9838d174bd7653 # shrinks to c = '`'
+cc 0f534d55f9771e8810b9c4252a4168abfaec1a35e1b0cac12dbaf726d295a08c # shrinks to c = '\0'
+cc 5d31bcbab722acd1f4e23ca3a4f95ff309a636b45a73ca8ae9f820d93ff57acc # shrinks to c = '{'
+cc 5afec063bc96160d681d77f90041b67ef5cfdea4dcbd12d984fd828fbeb4b421 # shrinks to c = '#'
+cc f919beb3ee5c70e756a15635d65ded7d44f3ae58b5e86b6c09e814d5d8cdd506 # shrinks to c = ';'
+cc ec00f39b8d45dfd8808947a56af5e50ba5a0ef7c951723b45377815a02e515b1 # shrinks to c = '('
+cc 25b773cdf4c24179151fa86244c7de4136e05df9e94e6ee77a336ebfd8764444 # shrinks to c = '|'
+cc 94dc0d54b97d59e1c0f4cb11bdccb3823a1bb908cbc3fd643ee8f067169fad72 # shrinks to c = '0'
+cc c9d0051fb1e5a8bdc1d4f5a3dceac1b4b465827d1dff4fc3a3755baae6a7bb48 # shrinks to c = '$'
+cc 14ec40d2eb5bd2663e9b11bb49fb2120852f9ea71678c69d732161412b55a3ec # shrinks to s = ""
+cc d4afccc51ed9d421bdb7e1723e273dfb6e77c3a449489671a496db234e87c5ed # shrinks to c = '\r'
+cc 515a56d73eb1b69290ef4c714b629421989879aebd57991bd2c2bf11294353b1 # shrinks to s = "\\\\𐊀{"
+cc 111566990fffa432acd2dbc845141b0e7870f97125c7621e3ddf142204568246 # shrinks to s = "'\":`"
+cc 0424c33000d9188be96b3049046eb052770b2158bf5ebb0c98656d7145e8aca9 # shrinks to s = "0"

crates/nu-command/src/bits/and.rs

@@ -0,0 +1,102 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "bits and"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bits and")
+            .input_output_types(vec![(Type::Int, Type::Int)])
+            .vectorizes_over_list(true)
+            .required(
+                "target",
+                SyntaxShape::Int,
+                "target integer to perform bit and",
+            )
+            .category(Category::Bits)
+    }
+
+    fn usage(&self) -> &str {
+        "Performs bitwise and for integers"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["logic and"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let target: i64 = call.req(engine_state, stack, 0)?;
+
+        input.map(
+            move |value| operate(value, target, head),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Apply bits and to two numbers",
+                example: "2 | bits and 2",
+                result: Some(Value::Int {
+                    val: 2,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Apply logical and to a list of numbers",
+                example: "[4 3 2] | bits and 2",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(0), Value::test_int(2), Value::test_int(2)],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn operate(value: Value, target: i64, head: Span) -> Value {
+    match value {
+        Value::Int { val, span } => Value::Int {
+            val: val & target,
+            span,
+        },
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Only integer values are supported, input type: {:?}",
+                    other.get_type()
+                ),
+                other.span().unwrap_or(head),
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/bits/bits_.rs

@@ -0,0 +1,55 @@
+use nu_engine::get_full_help;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, Signature, Value,
+};
+
+#[derive(Clone)]
+pub struct Bits;
+
+impl Command for Bits {
+    fn name(&self) -> &str {
+        "bits"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bits").category(Category::Bits)
+    }
+
+    fn usage(&self) -> &str {
+        "Various commands for working with bits"
+    }
+
+    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(
+                &Bits.signature(),
+                &Bits.examples(),
+                engine_state,
+                stack,
+                self.is_parser_keyword(),
+            ),
+            span: call.head,
+        }
+        .into_pipeline_data())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::Bits;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(Bits {})
+    }
+}

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

@@ -0,0 +1,99 @@
+mod and;
+mod bits_;
+mod not;
+mod or;
+mod rotate_left;
+mod rotate_right;
+mod shift_left;
+mod shift_right;
+mod xor;
+
+use nu_protocol::Spanned;
+
+pub use and::SubCommand as BitsAnd;
+pub use bits_::Bits;
+pub use not::SubCommand as BitsNot;
+pub use or::SubCommand as BitsOr;
+pub use rotate_left::SubCommand as BitsRotateLeft;
+pub use rotate_right::SubCommand as BitsRotateRight;
+pub use shift_left::SubCommand as BitsShiftLeft;
+pub use shift_right::SubCommand as BitsShiftRight;
+pub use xor::SubCommand as BitsXor;
+
+#[derive(Clone, Copy)]
+enum NumberBytes {
+    One,
+    Two,
+    Four,
+    Eight,
+    Auto,
+    Invalid,
+}
+
+#[derive(Clone, Copy)]
+enum InputNumType {
+    One,
+    Two,
+    Four,
+    Eight,
+    SignedOne,
+    SignedTwo,
+    SignedFour,
+    SignedEight,
+}
+
+fn get_number_bytes(number_bytes: &Option<Spanned<String>>) -> NumberBytes {
+    match number_bytes.as_ref() {
+        None => NumberBytes::Eight,
+        Some(size) => match size.item.as_str() {
+            "1" => NumberBytes::One,
+            "2" => NumberBytes::Two,
+            "4" => NumberBytes::Four,
+            "8" => NumberBytes::Eight,
+            "auto" => NumberBytes::Auto,
+            _ => NumberBytes::Invalid,
+        },
+    }
+}
+
+fn get_input_num_type(val: i64, signed: bool, number_size: NumberBytes) -> InputNumType {
+    if signed || val < 0 {
+        match number_size {
+            NumberBytes::One => InputNumType::SignedOne,
+            NumberBytes::Two => InputNumType::SignedTwo,
+            NumberBytes::Four => InputNumType::SignedFour,
+            NumberBytes::Eight => InputNumType::SignedEight,
+            NumberBytes::Auto => {
+                if val <= 0x7F && val >= -(2i64.pow(7)) {
+                    InputNumType::SignedOne
+                } else if val <= 0x7FFF && val >= -(2i64.pow(15)) {
+                    InputNumType::SignedTwo
+                } else if val <= 0x7FFFFFFF && val >= -(2i64.pow(31)) {
+                    InputNumType::SignedFour
+                } else {
+                    InputNumType::SignedEight
+                }
+            }
+            NumberBytes::Invalid => InputNumType::SignedFour,
+        }
+    } else {
+        match number_size {
+            NumberBytes::One => InputNumType::One,
+            NumberBytes::Two => InputNumType::Two,
+            NumberBytes::Four => InputNumType::Four,
+            NumberBytes::Eight => InputNumType::Eight,
+            NumberBytes::Auto => {
+                if val <= 0xFF {
+                    InputNumType::One
+                } else if val <= 0xFFFF {
+                    InputNumType::Two
+                } else if val <= 0xFFFFFFFF {
+                    InputNumType::Four
+                } else {
+                    InputNumType::Eight
+                }
+            }
+            NumberBytes::Invalid => InputNumType::Four,
+        }
+    }
+}

crates/nu-command/src/bits/not.rs

@@ -0,0 +1,165 @@
+use super::{get_number_bytes, NumberBytes};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "bits not"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bits not")
+            .input_output_types(vec![(Type::Int, Type::Int)])
+            .vectorizes_over_list(true)
+            .switch(
+                "signed",
+                "always treat input number as a signed number",
+                Some('s'),
+            )
+            .named(
+                "number-bytes",
+                SyntaxShape::String,
+                "the size of unsigned number in bytes, it can be 1, 2, 4, 8, auto",
+                Some('n'),
+            )
+            .category(Category::Bits)
+    }
+
+    fn usage(&self) -> &str {
+        "Performs logical negation on each bit"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["negation"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let signed = call.has_flag("signed");
+        let number_bytes: Option<Spanned<String>> =
+            call.get_flag(engine_state, stack, "number-bytes")?;
+        let bytes_len = get_number_bytes(&number_bytes);
+        if let NumberBytes::Invalid = bytes_len {
+            if let Some(val) = number_bytes {
+                return Err(ShellError::UnsupportedInput(
+                    "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
+                    val.span,
+                ));
+            }
+        }
+
+        input.map(
+            move |value| operate(value, head, signed, bytes_len),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Apply logical negation to a list of numbers",
+                example: "[4 3 2] | bits not",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::test_int(140737488355323),
+                        Value::test_int(140737488355324),
+                        Value::test_int(140737488355325),
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description:
+                    "Apply logical negation to a list of numbers, treat input as 2 bytes number",
+                example: "[4 3 2] | bits not -n 2",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::test_int(65531),
+                        Value::test_int(65532),
+                        Value::test_int(65533),
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description:
+                    "Apply logical negation to a list of numbers, treat input as signed number",
+                example: "[4 3 2] | bits not -s",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::test_int(-5),
+                        Value::test_int(-4),
+                        Value::test_int(-3),
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn operate(value: Value, head: Span, signed: bool, number_size: NumberBytes) -> Value {
+    match value {
+        Value::Int { val, span } => {
+            if signed || val < 0 {
+                Value::Int { val: !val, span }
+            } else {
+                use NumberBytes::*;
+                let out_val = match number_size {
+                    One => !val & 0x00_00_00_00_00_FF,
+                    Two => !val & 0x00_00_00_00_FF_FF,
+                    Four => !val & 0x00_00_FF_FF_FF_FF,
+                    Eight => !val & 0x7F_FF_FF_FF_FF_FF,
+                    Auto => {
+                        if val <= 0xFF {
+                            !val & 0x00_00_00_00_00_FF
+                        } else if val <= 0xFF_FF {
+                            !val & 0x00_00_00_00_FF_FF
+                        } else if val <= 0xFF_FF_FF_FF {
+                            !val & 0x00_00_FF_FF_FF_FF
+                        } else {
+                            !val & 0x7F_FF_FF_FF_FF_FF
+                        }
+                    }
+                    // This case shouldn't happen here, as it's handled before
+                    Invalid => 0,
+                };
+                Value::Int { val: out_val, span }
+            }
+        }
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Only numerical values are supported, input type: {:?}",
+                    other.get_type()
+                ),
+                other.span().unwrap_or(head),
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/bits/or.rs

@@ -0,0 +1,102 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "bits or"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bits or")
+            .input_output_types(vec![(Type::Int, Type::Int)])
+            .vectorizes_over_list(true)
+            .required(
+                "target",
+                SyntaxShape::Int,
+                "target integer to perform bit or",
+            )
+            .category(Category::Bits)
+    }
+
+    fn usage(&self) -> &str {
+        "Performs bitwise or for integers"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["logic or"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let target: i64 = call.req(engine_state, stack, 0)?;
+
+        input.map(
+            move |value| operate(value, target, head),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Apply bits or to two numbers",
+                example: "2 | bits or 6",
+                result: Some(Value::Int {
+                    val: 6,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Apply logical or to a list of numbers",
+                example: "[8 3 2] | bits or 2",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(10), Value::test_int(3), Value::test_int(2)],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn operate(value: Value, target: i64, head: Span) -> Value {
+    match value {
+        Value::Int { val, span } => Value::Int {
+            val: val | target,
+            span,
+        },
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Only integer values are supported, input type: {:?}",
+                    other.get_type()
+                ),
+                other.span().unwrap_or(head),
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/bits/rotate_left.rs

@@ -0,0 +1,158 @@
+use super::{get_input_num_type, get_number_bytes, InputNumType, NumberBytes};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
+};
+use num_traits::int::PrimInt;
+use std::fmt::Display;
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "bits rol"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bits rol")
+            .input_output_types(vec![(Type::Int, Type::Int)])
+            .vectorizes_over_list(true)
+            .required("bits", SyntaxShape::Int, "number of bits to rotate left")
+            .switch(
+                "signed",
+                "always treat input number as a signed number",
+                Some('s'),
+            )
+            .named(
+                "number-bytes",
+                SyntaxShape::String,
+                "the word size in number of bytes, it can be 1, 2, 4, 8, auto, default value `8`",
+                Some('n'),
+            )
+            .category(Category::Bits)
+    }
+
+    fn usage(&self) -> &str {
+        "Bitwise rotate left for integers"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["rotate left"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let bits: usize = call.req(engine_state, stack, 0)?;
+        let signed = call.has_flag("signed");
+        let number_bytes: Option<Spanned<String>> =
+            call.get_flag(engine_state, stack, "number-bytes")?;
+        let bytes_len = get_number_bytes(&number_bytes);
+        if let NumberBytes::Invalid = bytes_len {
+            if let Some(val) = number_bytes {
+                return Err(ShellError::UnsupportedInput(
+                    "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
+                    val.span,
+                ));
+            }
+        }
+
+        input.map(
+            move |value| operate(value, bits, head, signed, bytes_len),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Rotate left a number with 2 bits",
+                example: "17 | bits rol 2",
+                result: Some(Value::Int {
+                    val: 68,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Rotate left a list of numbers with 2 bits",
+                example: "[5 3 2] | bits rol 2",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(20), Value::test_int(12), Value::test_int(8)],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn get_rotate_left<T: Display + PrimInt>(val: T, bits: u32, span: Span) -> Value
+where
+    i64: std::convert::TryFrom<T>,
+{
+    let rotate_result = i64::try_from(val.rotate_left(bits));
+    match rotate_result {
+        Ok(val) => Value::Int { val, span },
+        Err(_) => Value::Error {
+            error: ShellError::GenericError(
+                "Rotate left result beyond the range of 64 bit signed number".to_string(),
+                format!(
+                    "{} of the specified number of bytes rotate left {} bits exceed limit",
+                    val, bits
+                ),
+                Some(span),
+                None,
+                Vec::new(),
+            ),
+        },
+    }
+}
+
+fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: NumberBytes) -> Value {
+    match value {
+        Value::Int { val, span } => {
+            use InputNumType::*;
+            // let bits = (((bits % 64) + 64) % 64) as u32;
+            let bits = bits as u32;
+            let input_type = get_input_num_type(val, signed, number_size);
+            match input_type {
+                One => get_rotate_left(val as u8, bits, span),
+                Two => get_rotate_left(val as u16, bits, span),
+                Four => get_rotate_left(val as u32, bits, span),
+                Eight => get_rotate_left(val as u64, bits, span),
+                SignedOne => get_rotate_left(val as i8, bits, span),
+                SignedTwo => get_rotate_left(val as i16, bits, span),
+                SignedFour => get_rotate_left(val as i32, bits, span),
+                SignedEight => get_rotate_left(val as i64, bits, span),
+            }
+        }
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Only integer values are supported, input type: {:?}",
+                    other.get_type()
+                ),
+                other.span().unwrap_or(head),
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/bits/rotate_right.rs

@@ -0,0 +1,162 @@
+use super::{get_input_num_type, get_number_bytes, InputNumType, NumberBytes};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
+};
+use num_traits::int::PrimInt;
+use std::fmt::Display;
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "bits ror"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bits ror")
+            .input_output_types(vec![(Type::Int, Type::Int)])
+            .vectorizes_over_list(true)
+            .required("bits", SyntaxShape::Int, "number of bits to rotate right")
+            .switch(
+                "signed",
+                "always treat input number as a signed number",
+                Some('s'),
+            )
+            .named(
+                "number-bytes",
+                SyntaxShape::String,
+                "the word size in number of bytes, it can be 1, 2, 4, 8, auto, default value `8`",
+                Some('n'),
+            )
+            .category(Category::Bits)
+    }
+
+    fn usage(&self) -> &str {
+        "Bitwise rotate right for integers"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["rotate right"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let bits: usize = call.req(engine_state, stack, 0)?;
+        let signed = call.has_flag("signed");
+        let number_bytes: Option<Spanned<String>> =
+            call.get_flag(engine_state, stack, "number-bytes")?;
+        let bytes_len = get_number_bytes(&number_bytes);
+        if let NumberBytes::Invalid = bytes_len {
+            if let Some(val) = number_bytes {
+                return Err(ShellError::UnsupportedInput(
+                    "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
+                    val.span,
+                ));
+            }
+        }
+
+        input.map(
+            move |value| operate(value, bits, head, signed, bytes_len),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Rotate right a number with 60 bits",
+                example: "17 | bits ror 60",
+                result: Some(Value::Int {
+                    val: 272,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Rotate right a list of numbers of one byte",
+                example: "[15 33 92] | bits ror 2 -n 1",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::test_int(195),
+                        Value::test_int(72),
+                        Value::test_int(23),
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn get_rotate_right<T: Display + PrimInt>(val: T, bits: u32, span: Span) -> Value
+where
+    i64: std::convert::TryFrom<T>,
+{
+    let rotate_result = i64::try_from(val.rotate_right(bits));
+    match rotate_result {
+        Ok(val) => Value::Int { val, span },
+        Err(_) => Value::Error {
+            error: ShellError::GenericError(
+                "Rotate right result beyond the range of 64 bit signed number".to_string(),
+                format!(
+                    "{} of the specified number of bytes rotate right {} bits exceed limit",
+                    val, bits
+                ),
+                Some(span),
+                None,
+                Vec::new(),
+            ),
+        },
+    }
+}
+
+fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: NumberBytes) -> Value {
+    match value {
+        Value::Int { val, span } => {
+            use InputNumType::*;
+            // let bits = (((bits % 64) + 64) % 64) as u32;
+            let bits = bits as u32;
+            let input_type = get_input_num_type(val, signed, number_size);
+            match input_type {
+                One => get_rotate_right(val as u8, bits, span),
+                Two => get_rotate_right(val as u16, bits, span),
+                Four => get_rotate_right(val as u32, bits, span),
+                Eight => get_rotate_right(val as u64, bits, span),
+                SignedOne => get_rotate_right(val as i8, bits, span),
+                SignedTwo => get_rotate_right(val as i16, bits, span),
+                SignedFour => get_rotate_right(val as i32, bits, span),
+                SignedEight => get_rotate_right(val as i64, bits, span),
+            }
+        }
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Only integer values are supported, input type: {:?}",
+                    other.get_type()
+                ),
+                other.span().unwrap_or(head),
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/bits/shift_left.rs

@@ -0,0 +1,190 @@
+use super::{get_input_num_type, get_number_bytes, InputNumType, NumberBytes};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
+};
+use num_traits::CheckedShl;
+use std::fmt::Display;
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "bits shl"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bits shl")
+            .input_output_types(vec![(Type::Int, Type::Int)])
+            .vectorizes_over_list(true)
+            .required("bits", SyntaxShape::Int, "number of bits to shift left")
+            .switch(
+                "signed",
+                "always treat input number as a signed number",
+                Some('s'),
+            )
+            .named(
+                "number-bytes",
+                SyntaxShape::String,
+                "the word size in number of bytes, it can be 1, 2, 4, 8, auto, default value `8`",
+                Some('n'),
+            )
+            .category(Category::Bits)
+    }
+
+    fn usage(&self) -> &str {
+        "Bitwise shift left for integers"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["shift left"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let bits: usize = call.req(engine_state, stack, 0)?;
+        let signed = call.has_flag("signed");
+        let number_bytes: Option<Spanned<String>> =
+            call.get_flag(engine_state, stack, "number-bytes")?;
+        let bytes_len = get_number_bytes(&number_bytes);
+        if let NumberBytes::Invalid = bytes_len {
+            if let Some(val) = number_bytes {
+                return Err(ShellError::UnsupportedInput(
+                    "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
+                    val.span,
+                ));
+            }
+        }
+
+        input.map(
+            move |value| operate(value, bits, head, signed, bytes_len),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Shift left a number by 7 bits",
+                example: "2 | bits shl 7",
+                result: Some(Value::Int {
+                    val: 256,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Shift left a number with 1 byte by 7 bits",
+                example: "2 | bits shl 7 -n 1",
+                result: Some(Value::Int {
+                    val: 0,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Shift left a signed number by 1 bit",
+                example: "0x7F | bits shl 1 -s",
+                result: Some(Value::Int {
+                    val: 254,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Shift left a list of numbers",
+                example: "[5 3 2] | bits shl 2",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(20), Value::test_int(12), Value::test_int(8)],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn get_shift_left<T: CheckedShl + Display + Copy>(val: T, bits: u32, span: Span) -> Value
+where
+    i64: std::convert::TryFrom<T>,
+{
+    match val.checked_shl(bits) {
+        Some(val) => {
+            let shift_result = i64::try_from(val);
+            match shift_result {
+                Ok(val) => Value::Int { val, span },
+                Err(_) => Value::Error {
+                    error: ShellError::GenericError(
+                        "Shift left result beyond the range of 64 bit signed number".to_string(),
+                        format!(
+                            "{} of the specified number of bytes shift left {} bits exceed limit",
+                            val, bits
+                        ),
+                        Some(span),
+                        None,
+                        Vec::new(),
+                    ),
+                },
+            }
+        }
+        None => Value::Error {
+            error: ShellError::GenericError(
+                "Shift left failed".to_string(),
+                format!(
+                    "{} shift left {} bits failed, you may shift too many bits",
+                    val, bits
+                ),
+                Some(span),
+                None,
+                Vec::new(),
+            ),
+        },
+    }
+}
+
+fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: NumberBytes) -> Value {
+    match value {
+        Value::Int { val, span } => {
+            use InputNumType::*;
+            // let bits = (((bits % 64) + 64) % 64) as u32;
+            let bits = bits as u32;
+            let input_type = get_input_num_type(val, signed, number_size);
+            match input_type {
+                One => get_shift_left(val as u8, bits, span),
+                Two => get_shift_left(val as u16, bits, span),
+                Four => get_shift_left(val as u32, bits, span),
+                Eight => get_shift_left(val as u64, bits, span),
+                SignedOne => get_shift_left(val as i8, bits, span),
+                SignedTwo => get_shift_left(val as i16, bits, span),
+                SignedFour => get_shift_left(val as i32, bits, span),
+                SignedEight => get_shift_left(val as i64, bits, span),
+            }
+        }
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Only integer values are supported, input type: {:?}",
+                    other.get_type()
+                ),
+                other.span().unwrap_or(head),
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/bits/shift_right.rs

@@ -0,0 +1,174 @@
+use super::{get_input_num_type, get_number_bytes, InputNumType, NumberBytes};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
+};
+use num_traits::CheckedShr;
+use std::fmt::Display;
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "bits shr"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bits shr")
+            .input_output_types(vec![(Type::Int, Type::Int)])
+            .vectorizes_over_list(true)
+            .required("bits", SyntaxShape::Int, "number of bits to shift right")
+            .switch(
+                "signed",
+                "always treat input number as a signed number",
+                Some('s'),
+            )
+            .named(
+                "number-bytes",
+                SyntaxShape::String,
+                "the word size in number of bytes, it can be 1, 2, 4, 8, auto, default value `8`",
+                Some('n'),
+            )
+            .category(Category::Bits)
+    }
+
+    fn usage(&self) -> &str {
+        "Bitwise shift right for integers"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["shift right"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let bits: usize = call.req(engine_state, stack, 0)?;
+        let signed = call.has_flag("signed");
+        let number_bytes: Option<Spanned<String>> =
+            call.get_flag(engine_state, stack, "number-bytes")?;
+        let bytes_len = get_number_bytes(&number_bytes);
+        if let NumberBytes::Invalid = bytes_len {
+            if let Some(val) = number_bytes {
+                return Err(ShellError::UnsupportedInput(
+                    "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
+                    val.span,
+                ));
+            }
+        }
+
+        input.map(
+            move |value| operate(value, bits, head, signed, bytes_len),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Shift right a number with 2 bits",
+                example: "8 | bits shr 2",
+                result: Some(Value::Int {
+                    val: 2,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Shift right a list of numbers",
+                example: "[15 35 2] | bits shr 2",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(3), Value::test_int(8), Value::test_int(0)],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn get_shift_right<T: CheckedShr + Display + Copy>(val: T, bits: u32, span: Span) -> Value
+where
+    i64: std::convert::TryFrom<T>,
+{
+    match val.checked_shr(bits) {
+        Some(val) => {
+            let shift_result = i64::try_from(val);
+            match shift_result {
+                Ok(val) => Value::Int { val, span },
+                Err(_) => Value::Error {
+                    error: ShellError::GenericError(
+                        "Shift right result beyond the range of 64 bit signed number".to_string(),
+                        format!(
+                            "{} of the specified number of bytes shift right {} bits exceed limit",
+                            val, bits
+                        ),
+                        Some(span),
+                        None,
+                        Vec::new(),
+                    ),
+                },
+            }
+        }
+        None => Value::Error {
+            error: ShellError::GenericError(
+                "Shift right failed".to_string(),
+                format!(
+                    "{} shift right {} bits failed, you may shift too many bits",
+                    val, bits
+                ),
+                Some(span),
+                None,
+                Vec::new(),
+            ),
+        },
+    }
+}
+
+fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: NumberBytes) -> Value {
+    match value {
+        Value::Int { val, span } => {
+            use InputNumType::*;
+            // let bits = (((bits % 64) + 64) % 64) as u32;
+            let bits = bits as u32;
+            let input_type = get_input_num_type(val, signed, number_size);
+            match input_type {
+                One => get_shift_right(val as u8, bits, span),
+                Two => get_shift_right(val as u16, bits, span),
+                Four => get_shift_right(val as u32, bits, span),
+                Eight => get_shift_right(val as u64, bits, span),
+                SignedOne => get_shift_right(val as i8, bits, span),
+                SignedTwo => get_shift_right(val as i16, bits, span),
+                SignedFour => get_shift_right(val as i32, bits, span),
+                SignedEight => get_shift_right(val as i64, bits, span),
+            }
+        }
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Only integer values are supported, input type: {:?}",
+                    other.get_type()
+                ),
+                other.span().unwrap_or(head),
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/bits/xor.rs

@@ -0,0 +1,102 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "bits xor"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bits xor")
+            .input_output_types(vec![(Type::Int, Type::Int)])
+            .vectorizes_over_list(true)
+            .required(
+                "target",
+                SyntaxShape::Int,
+                "target integer to perform bit xor",
+            )
+            .category(Category::Bits)
+    }
+
+    fn usage(&self) -> &str {
+        "Performs bitwise xor for integers"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["logic xor"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let head = call.head;
+        let target: i64 = call.req(engine_state, stack, 0)?;
+
+        input.map(
+            move |value| operate(value, target, head),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Apply bits xor to two numbers",
+                example: "2 | bits xor 2",
+                result: Some(Value::Int {
+                    val: 0,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Apply logical xor to a list of numbers",
+                example: "[8 3 2] | bits xor 2",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(10), Value::test_int(1), Value::test_int(0)],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn operate(value: Value, target: i64, head: Span) -> Value {
+    match value {
+        Value::Int { val, span } => Value::Int {
+            val: val ^ target,
+            span,
+        },
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Only integer values are supported, input type: {:?}",
+                    other.get_type()
+                ),
+                other.span().unwrap_or(head),
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/bytes/add.rs

@@ -0,0 +1,183 @@
+use crate::input_handler::{operate, CmdArgument};
+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;
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
+
+struct Arguments {
+    added_data: Vec<u8>,
+    index: Option<usize>,
+    end: bool,
+    cell_paths: Option<Vec<CellPath>>,
+}
+
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
+    }
+}
+
+#[derive(Clone)]
+
+pub struct BytesAdd;
+
+impl Command for BytesAdd {
+    fn name(&self) -> &str {
+        "bytes add"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes add")
+            .input_output_types(vec![(Type::Binary, Type::Binary)])
+            .vectorizes_over_list(true)
+            .required("data", SyntaxShape::Binary, "the binary to add")
+            .named(
+                "index",
+                SyntaxShape::Int,
+                "index to insert binary data",
+                Some('i'),
+            )
+            .switch("end", "add to the end of binary", Some('e'))
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "for a data structure input, add bytes to the data at the given cell paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Add specified bytes to the input"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["append", "truncate", "padding"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let added_data: Vec<u8> = call.req(engine_state, stack, 0)?;
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let index: Option<usize> = call.get_flag(engine_state, stack, "index")?;
+        let end = call.has_flag("end");
+
+        let arg = Arguments {
+            added_data,
+            index,
+            end,
+            cell_paths,
+        };
+        operate(add, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Add bytes `0x[AA]` to `0x[1F FF AA AA]`",
+                example: "0x[1F FF AA AA] | bytes add 0x[AA]",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0x1F, 0xFF, 0xAA, 0xAA],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Add bytes `0x[AA BB]` to `0x[1F FF AA AA]` at index 1",
+                example: "0x[1F FF AA AA] | bytes add 0x[AA BB] -i 1",
+                result: Some(Value::Binary {
+                    val: vec![0x1F, 0xAA, 0xBB, 0xFF, 0xAA, 0xAA],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Add bytes `0x[11]` to `0x[FF AA AA]` at the end",
+                example: "0x[FF AA AA] | bytes add 0x[11] -e",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xAA, 0xAA, 0x11],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Add bytes `0x[11 22 33]` to `0x[FF AA AA]` at the end, at index 1(the index is start from end)",
+                example: "0x[FF AA BB] | bytes add 0x[11 22 33] -e -i 1",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xAA, 0x11, 0x22, 0x33, 0xBB],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn add(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => add_impl(val, args, *val_span),
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+fn add_impl(input: &[u8], args: &Arguments, span: Span) -> Value {
+    match args.index {
+        None => {
+            if args.end {
+                let mut added_data = args.added_data.clone();
+                let mut result = input.to_vec();
+                result.append(&mut added_data);
+                Value::Binary { val: result, span }
+            } else {
+                let mut result = args.added_data.clone();
+                let mut input = input.to_vec();
+                result.append(&mut input);
+                Value::Binary { val: result, span }
+            }
+        }
+        Some(mut indx) => {
+            let inserted_index = if args.end {
+                input.len().saturating_sub(indx)
+            } else {
+                if indx > input.len() {
+                    indx = input.len()
+                }
+                indx
+            };
+            let mut result = vec![];
+            let mut prev_data = input[..inserted_index].to_vec();
+            result.append(&mut prev_data);
+            let mut added_data = args.added_data.clone();
+            result.append(&mut added_data);
+            let mut after_data = input[inserted_index..].to_vec();
+            result.append(&mut after_data);
+            Value::Binary { val: result, span }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesAdd {})
+    }
+}

crates/nu-command/src/bytes/at.rs

@@ -0,0 +1,297 @@
+use crate::input_handler::{operate, CmdArgument};
+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, SyntaxShape, Type, Value,
+};
+use std::cmp::Ordering;
+
+#[derive(Clone)]
+pub struct BytesAt;
+
+struct Arguments {
+    start: isize,
+    end: isize,
+    arg_span: Span,
+    cell_paths: Option<Vec<CellPath>>,
+}
+
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
+    }
+}
+
+/// ensure given `range` is valid, and returns [start, end, val_span] pair.
+fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellError> {
+    let (start, end, span) = match range {
+        Value::List { mut vals, span } => {
+            if vals.len() != 2 {
+                return Err(ShellError::UnsupportedInput(
+                    "More than two indices given".to_string(),
+                    span,
+                ));
+            } else {
+                let end = vals.pop().expect("Already check has size 2");
+                let end = match end {
+                    Value::Int { val, .. } => val.to_string(),
+                    Value::String { val, .. } => val,
+                    other => {
+                        return Err(ShellError::UnsupportedInput(
+                            "could not perform subbytes. Expecting a string or int".to_string(),
+                            other.span().unwrap_or(head),
+                        ))
+                    }
+                };
+                let start = vals.pop().expect("Already check has size 1");
+                let start = match start {
+                    Value::Int { val, .. } => val.to_string(),
+                    Value::String { val, .. } => val,
+                    other => {
+                        return Err(ShellError::UnsupportedInput(
+                            "could not perform subbytes. Expecting a string or int".to_string(),
+                            other.span().unwrap_or(head),
+                        ))
+                    }
+                };
+                (start, end, span)
+            }
+        }
+        Value::String { val, span } => {
+            let splitted_result = val.split_once(',');
+            match splitted_result {
+                Some((start, end)) => (start.to_string(), end.to_string(), span),
+                None => {
+                    return Err(ShellError::UnsupportedInput(
+                        "could not perform subbytes".to_string(),
+                        span,
+                    ))
+                }
+            }
+        }
+        other => {
+            return Err(ShellError::UnsupportedInput(
+                "could not perform subbytes".to_string(),
+                other.span().unwrap_or(head),
+            ))
+        }
+    };
+
+    let start: isize = if start.is_empty() || start == "_" {
+        0
+    } else {
+        match start.trim().parse() {
+            Ok(s) => s,
+            Err(_) => {
+                return Err(ShellError::UnsupportedInput(
+                    "could not perform subbytes".to_string(),
+                    span,
+                ))
+            }
+        }
+    };
+    let end: isize = if end.is_empty() || end == "_" {
+        isize::max_value()
+    } else {
+        match end.trim().parse() {
+            Ok(s) => s,
+            Err(_) => {
+                return Err(ShellError::UnsupportedInput(
+                    "could not perform subbytes".to_string(),
+                    span,
+                ))
+            }
+        }
+    };
+    Ok((start, end, span))
+}
+
+impl Command for BytesAt {
+    fn name(&self) -> &str {
+        "bytes at"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes at")
+            .input_output_types(vec![(Type::Binary, Type::Binary)])
+            .vectorizes_over_list(true)
+            .required("range", SyntaxShape::Any, "the indexes to get bytes")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "for a data structure input, get bytes from data at the given cell paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Get bytes defined by a range. Note that the start is included but the end is excluded, and that the first byte is index 0."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["slice"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let range: Value = call.req(engine_state, stack, 0)?;
+        let (start, end, arg_span) = parse_range(range, call.head)?;
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let arg = Arguments {
+            start,
+            end,
+            arg_span,
+            cell_paths,
+        };
+        operate(at, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get a subbytes `0x[10 01]` from the bytes `0x[33 44 55 10 01 13]`",
+                example: " 0x[33 44 55 10 01 13] | bytes at [3 4]",
+                result: Some(Value::Binary {
+                    val: vec![0x10],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Alternatively, you can use the form",
+                example: " 0x[33 44 55 10 01 13] | bytes at '3,4'",
+                result: Some(Value::Binary {
+                    val: vec![0x10],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Drop the last `n` characters from the string",
+                example: " 0x[33 44 55 10 01 13] | bytes at ',-3'",
+                result: Some(Value::Binary {
+                    val: vec![0x33, 0x44, 0x55],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Get the remaining characters from a starting index",
+                example: " 0x[33 44 55 10 01 13] | bytes at '3,'",
+                result: Some(Value::Binary {
+                    val: vec![0x10, 0x01, 0x13],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Get the characters from the beginning until ending index",
+                example: " 0x[33 44 55 10 01 13] | bytes at ',4'",
+                result: Some(Value::Binary {
+                    val: vec![0x33, 0x44, 0x55, 0x10],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description:
+                    "Or the characters from the beginning until ending index inside a table",
+                example: r#" [[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes at "1," ColB ColC"#,
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::Binary {
+                                val: vec![0x11, 0x12, 0x13],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x18, 0x19],
+                                span: Span::test_data(),
+                            },
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn at(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => at_impl(val, args, *val_span),
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+fn at_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    let len: isize = input.len() as isize;
+
+    let start: isize = if arg.start < 0 {
+        arg.start + len
+    } else {
+        arg.start
+    };
+    let end: isize = if arg.end < 0 {
+        std::cmp::max(len + arg.end, 0)
+    } else {
+        arg.end
+    };
+
+    if start < len && end >= 0 {
+        match start.cmp(&end) {
+            Ordering::Equal => Value::Binary { val: vec![], span },
+            Ordering::Greater => Value::Error {
+                error: ShellError::UnsupportedInput(
+                    "End must be greater than or equal to Start".to_string(),
+                    arg.arg_span,
+                ),
+            },
+            Ordering::Less => Value::Binary {
+                val: {
+                    let input_iter = input.iter().copied().skip(start as usize);
+                    if end == isize::max_value() {
+                        input_iter.collect()
+                    } else {
+                        input_iter.take((end - start) as usize).collect()
+                    }
+                },
+                span,
+            },
+        }
+    } else {
+        Value::Binary { val: vec![], span }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesAt {})
+    }
+}

crates/nu-command/src/bytes/build_.rs

@@ -0,0 +1,82 @@
+use nu_engine::eval_expression;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Type, Value,
+};
+
+#[derive(Clone)]
+pub struct BytesBuild;
+
+impl Command for BytesBuild {
+    fn name(&self) -> &str {
+        "bytes build"
+    }
+
+    fn usage(&self) -> &str {
+        "Create bytes from the arguments."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["concatenate", "join"]
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("bytes build")
+            .input_output_types(vec![(Type::Nothing, Type::Binary)])
+            .rest("rest", SyntaxShape::Any, "list of bytes")
+            .category(Category::Bytes)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            example: "bytes build 0x[01 02] 0x[03] 0x[04]",
+            description: "Builds binary data from 0x[01 02], 0x[03], 0x[04]",
+            result: Some(Value::Binary {
+                val: vec![0x01, 0x02, 0x03, 0x04],
+                span: Span::test_data(),
+            }),
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let mut output = vec![];
+        for expr in call.positional_iter() {
+            let val = eval_expression(engine_state, stack, expr)?;
+            match val {
+                Value::Binary { mut val, .. } => output.append(&mut val),
+                other => {
+                    return Err(ShellError::UnsupportedInput(
+                        "only support expression which yields to binary data".to_string(),
+                        other.span().unwrap_or(call.head),
+                    ))
+                }
+            }
+        }
+
+        Ok(Value::Binary {
+            val: output,
+            span: call.head,
+        }
+        .into_pipeline_data())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesBuild {})
+    }
+}

crates/nu-command/src/bytes/bytes_.rs

@@ -0,0 +1,55 @@
+use nu_engine::get_full_help;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, Signature, Value,
+};
+
+#[derive(Clone)]
+pub struct Bytes;
+
+impl Command for Bytes {
+    fn name(&self) -> &str {
+        "bytes"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes").category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Various commands for working with byte data"
+    }
+
+    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(
+                &Bytes.signature(),
+                &Bytes.examples(),
+                engine_state,
+                stack,
+                self.is_parser_keyword(),
+            ),
+            span: call.head,
+        }
+        .into_pipeline_data())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::Bytes;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(Bytes {})
+    }
+}

crates/nu-command/src/bytes/collect.rs

@@ -0,0 +1,128 @@
+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,
+    Type, Value,
+};
+
+#[derive(Clone, Copy)]
+pub struct BytesCollect;
+
+impl Command for BytesCollect {
+    fn name(&self) -> &str {
+        "bytes collect"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes collect")
+            .input_output_types(vec![(Type::List(Box::new(Type::Binary)), Type::Binary)])
+            .optional(
+                "separator",
+                SyntaxShape::Binary,
+                "optional separator to use when creating binary",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Concatenate multiple binary into a single binary, with an optional separator between each"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["join", "concatenate"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let separator: Option<Vec<u8>> = call.opt(engine_state, stack, 0)?;
+        // input should be a list of binary data.
+        let mut output_binary = vec![];
+        for value in input {
+            match value {
+                Value::Binary { mut val, .. } => {
+                    output_binary.append(&mut val);
+                    // manually concat
+                    // TODO: make use of std::slice::Join when it's available in stable.
+                    if let Some(sep) = &separator {
+                        let mut work_sep = sep.clone();
+                        output_binary.append(&mut work_sep)
+                    }
+                }
+                other => {
+                    return Err(ShellError::UnsupportedInput(
+                        format!(
+                            "The element type is {}, this command only works with bytes.",
+                            other.get_type()
+                        ),
+                        other.span().unwrap_or(call.head),
+                    ))
+                }
+            }
+        }
+
+        match separator {
+            None => Ok(Value::Binary {
+                val: output_binary,
+                span: call.head,
+            }
+            .into_pipeline_data()),
+            Some(sep) => {
+                if output_binary.is_empty() {
+                    Ok(Value::Binary {
+                        val: output_binary,
+                        span: call.head,
+                    }
+                    .into_pipeline_data())
+                } else {
+                    // have push one extra separator in previous step, pop them out.
+                    for _ in sep {
+                        let _ = output_binary.pop();
+                    }
+                    Ok(Value::Binary {
+                        val: output_binary,
+                        span: call.head,
+                    }
+                    .into_pipeline_data())
+                }
+            }
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Create a byte array from input",
+                example: "[0x[11] 0x[13 15]] | bytes collect",
+                result: Some(Value::Binary {
+                    val: vec![0x11, 0x13, 0x15],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Create a byte array from input with a separator",
+                example: "[0x[11] 0x[33] 0x[44]] | bytes collect 0x[01]",
+                result: Some(Value::Binary {
+                    val: vec![0x11, 0x01, 0x33, 0x01, 0x44],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesCollect {})
+    }
+}

crates/nu-command/src/bytes/ends_with.rs

@@ -0,0 +1,127 @@
+use crate::input_handler::{operate, CmdArgument};
+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;
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    cell_paths: Option<Vec<CellPath>>,
+}
+
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
+    }
+}
+
+#[derive(Clone)]
+
+pub struct BytesEndsWith;
+
+impl Command for BytesEndsWith {
+    fn name(&self) -> &str {
+        "bytes ends-with"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes ends-with")
+            .input_output_types(vec![(Type::Binary, Type::Bool)])
+            .required("pattern", SyntaxShape::Binary, "the pattern to match")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "for a data structure input, check if bytes at the given cell paths end with the pattern",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Check if bytes ends with a pattern"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["pattern", "match", "find", "search"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let arg = Arguments {
+            pattern,
+            cell_paths,
+        };
+        operate(ends_with, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Checks if binary ends with `0x[AA]`",
+                example: "0x[1F FF AA AA] | bytes ends-with 0x[AA]",
+                result: Some(Value::Bool {
+                    val: true,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Checks if binary ends with `0x[FF AA AA]`",
+                example: "0x[1F FF AA AA] | bytes ends-with 0x[FF AA AA]",
+                result: Some(Value::Bool {
+                    val: true,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Checks if binary ends with `0x[11]`",
+                example: "0x[1F FF AA AA] | bytes ends-with 0x[11]",
+                result: Some(Value::Bool {
+                    val: false,
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn ends_with(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => Value::Bool {
+            val: val.ends_with(&args.pattern),
+            span: *val_span,
+        },
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesEndsWith {})
+    }
+}

crates/nu-command/src/bytes/index_of.rs

@@ -0,0 +1,228 @@
+use crate::input_handler::{operate, CmdArgument};
+use nu_engine::CallExt;
+use nu_protocol::ast::{Call, CellPath};
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    end: bool,
+    all: bool,
+    cell_paths: Option<Vec<CellPath>>,
+}
+
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
+    }
+}
+
+#[derive(Clone)]
+pub struct BytesIndexOf;
+
+impl Command for BytesIndexOf {
+    fn name(&self) -> &str {
+        "bytes index-of"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes index-of")
+            .input_output_types(vec![
+                (Type::Binary, Type::Int),
+                (Type::Binary, Type::List(Box::new(Type::Int))),
+            ])
+            .required(
+                "pattern",
+                SyntaxShape::Binary,
+                "the pattern to find index of",
+            )
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "for a data structure input, find the indexes at the given cell paths",
+            )
+            .switch("all", "returns all matched index", Some('a'))
+            .switch("end", "search from the end of the binary", Some('e'))
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Returns start index of first occurrence of pattern in bytes, or -1 if no match"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["pattern", "match", "find", "search"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let arg = Arguments {
+            pattern,
+            end: call.has_flag("end"),
+            all: call.has_flag("all"),
+            cell_paths,
+        };
+        operate(index_of, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Returns index of pattern in bytes",
+                example: " 0x[33 44 55 10 01 13 44 55] | bytes index-of 0x[44 55]",
+                result: Some(Value::test_int(1)),
+            },
+            Example {
+                description: "Returns index of pattern, search from end",
+                example: " 0x[33 44 55 10 01 13 44 55] | bytes index-of -e 0x[44 55]",
+                result: Some(Value::test_int(6)),
+            },
+            Example {
+                description: "Returns all matched index",
+                example: " 0x[33 44 55 10 01 33 44 33 44] | bytes index-of -a 0x[33 44]",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(0), Value::test_int(5), Value::test_int(7)],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Returns all matched index, searching from end",
+                example: " 0x[33 44 55 10 01 33 44 33 44] | bytes index-of -a -e 0x[33 44]",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(7), Value::test_int(5), Value::test_int(0)],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Returns index of pattern for specific column",
+                example: r#" [[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes index-of 0x[11] ColA ColC"#,
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::test_int(0),
+                            Value::Binary {
+                                val: vec![0x14, 0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::test_int(-1),
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn index_of(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => index_of_impl(val, args, *val_span),
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+fn index_of_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    if arg.all {
+        search_all_index(input, &arg.pattern, arg.end, span)
+    } else {
+        let mut iter = input.windows(arg.pattern.len());
+
+        if arg.end {
+            Value::Int {
+                val: iter
+                    .rev()
+                    .position(|sub_bytes| sub_bytes == arg.pattern)
+                    .map(|x| (input.len() - arg.pattern.len() - x) as i64)
+                    .unwrap_or(-1),
+                span,
+            }
+        } else {
+            Value::Int {
+                val: iter
+                    .position(|sub_bytes| sub_bytes == arg.pattern)
+                    .map(|x| x as i64)
+                    .unwrap_or(-1),
+                span,
+            }
+        }
+    }
+}
+
+fn search_all_index(input: &[u8], pattern: &[u8], from_end: bool, span: Span) -> Value {
+    let mut result = vec![];
+    if from_end {
+        let (mut left, mut right) = (
+            input.len() as isize - pattern.len() as isize,
+            input.len() as isize,
+        );
+        while left >= 0 {
+            if &input[left as usize..right as usize] == pattern {
+                result.push(Value::Int {
+                    val: left as i64,
+                    span,
+                });
+                left -= pattern.len() as isize;
+                right -= pattern.len() as isize;
+            } else {
+                left -= 1;
+                right -= 1;
+            }
+        }
+        Value::List { vals: result, span }
+    } else {
+        // doing find stuff.
+        let (mut left, mut right) = (0, pattern.len());
+        let input_len = input.len();
+        let pattern_len = pattern.len();
+        while right <= input_len {
+            if &input[left..right] == pattern {
+                result.push(Value::Int {
+                    val: left as i64,
+                    span,
+                });
+                left += pattern_len;
+                right += pattern_len;
+            } else {
+                left += 1;
+                right += 1;
+            }
+        }
+
+        Value::List { vals: result, span }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesIndexOf {})
+    }
+}

crates/nu-command/src/bytes/length.rs

@@ -0,0 +1,99 @@
+use crate::input_handler::{operate, CellPathOnlyArgs};
+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;
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
+
+#[derive(Clone)]
+pub struct BytesLen;
+
+impl Command for BytesLen {
+    fn name(&self) -> &str {
+        "bytes length"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes length")
+            .input_output_types(vec![(Type::Binary, Type::Int)])
+            .vectorizes_over_list(true)
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "for a data structure input, find the length of data at the given cell paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Output the length of any bytes in the pipeline"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["size", "count"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let arg = CellPathOnlyArgs::from(cell_paths);
+        operate(length, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Return the lengths of multiple strings",
+                example: "0x[1F FF AA AB] | bytes length",
+                result: Some(Value::test_int(4)),
+            },
+            Example {
+                description: "Return the lengths of multiple strings",
+                example: "[0x[1F FF AA AB] 0x[1F]] | bytes length",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(4), Value::test_int(1)],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn length(val: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => Value::Int {
+            val: val.len() as i64,
+            span: *val_span,
+        },
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesLen {})
+    }
+}

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

@@ -0,0 +1,25 @@
+mod add;
+mod at;
+mod build_;
+mod bytes_;
+mod collect;
+mod ends_with;
+mod index_of;
+mod length;
+mod remove;
+mod replace;
+mod reverse;
+mod starts_with;
+
+pub use add::BytesAdd;
+pub use at::BytesAt;
+pub use build_::BytesBuild;
+pub use bytes_::Bytes;
+pub use collect::BytesCollect;
+pub use ends_with::BytesEndsWith;
+pub use index_of::BytesIndexOf;
+pub use length::BytesLen;
+pub use remove::BytesRemove;
+pub use replace::BytesReplace;
+pub use reverse::BytesReverse;
+pub use starts_with::BytesStartsWith;

crates/nu-command/src/bytes/remove.rs

@@ -0,0 +1,212 @@
+use crate::input_handler::{operate, CmdArgument};
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type,
+    Value,
+};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    end: bool,
+    cell_paths: Option<Vec<CellPath>>,
+    all: bool,
+}
+
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
+    }
+}
+
+#[derive(Clone)]
+pub struct BytesRemove;
+
+impl Command for BytesRemove {
+    fn name(&self) -> &str {
+        "bytes remove"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes remove")
+            .input_output_types(vec![(Type::Binary, Type::Binary)])
+            .required("pattern", SyntaxShape::Binary, "the pattern to find")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "for a data structure input, remove bytes from data at the given cell paths",
+            )
+            .switch("end", "remove from end of binary", Some('e'))
+            .switch("all", "remove occurrences of finding binary", Some('a'))
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Remove bytes"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["search", "shift", "switch"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let pattern_to_remove = call.req::<Spanned<Vec<u8>>>(engine_state, stack, 0)?;
+        if pattern_to_remove.item.is_empty() {
+            return Err(ShellError::UnsupportedInput(
+                "the pattern to remove cannot be empty".to_string(),
+                pattern_to_remove.span,
+            ));
+        }
+
+        let pattern_to_remove: Vec<u8> = pattern_to_remove.item;
+        let arg = Arguments {
+            pattern: pattern_to_remove,
+            end: call.has_flag("end"),
+            cell_paths,
+            all: call.has_flag("all"),
+        };
+
+        operate(remove, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Remove contents",
+                example: "0x[10 AA FF AA FF] | bytes remove 0x[10 AA]",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xAA, 0xFF],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Remove all occurrences of find binary",
+                example: "0x[10 AA 10 BB 10] | bytes remove -a 0x[10]",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0xBB],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Remove occurrences of find binary from end",
+                example: "0x[10 AA 10 BB CC AA 10] | bytes remove -e 0x[10]",
+                result: Some(Value::Binary {
+                    val: vec![0x10, 0xAA, 0x10, 0xBB, 0xCC, 0xAA],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Remove all occurrences of find binary in table",
+                example: "[[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes remove 0x[11] ColA ColC",
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::Binary {
+                                val: vec![0x12, 0x13],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x14, 0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x17, 0x18, 0x19],
+                                span: Span::test_data(),
+                            },
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn remove(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => remove_impl(val, args, *val_span),
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+fn remove_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    let mut result = vec![];
+    let remove_all = arg.all;
+    let input_len = input.len();
+    let pattern_len = arg.pattern.len();
+
+    // Note:
+    // remove_all from start and end will generate the same result.
+    // so we'll put `remove_all` relative logic into else clouse.
+    if arg.end && !remove_all {
+        let (mut left, mut right) = (
+            input.len() as isize - arg.pattern.len() as isize,
+            input.len() as isize,
+        );
+        while left >= 0 && input[left as usize..right as usize] != arg.pattern {
+            result.push(input[right as usize - 1]);
+            left -= 1;
+            right -= 1;
+        }
+        // append the remaining thing to result, this can be happeneed when
+        // we have something to remove and remove_all is False.
+        let mut remain = input[..left as usize].iter().copied().rev().collect();
+        result.append(&mut remain);
+        result = result.into_iter().rev().collect();
+        Value::Binary { val: result, span }
+    } else {
+        let (mut left, mut right) = (0, arg.pattern.len());
+        while right <= input_len {
+            if input[left..right] == arg.pattern {
+                left += pattern_len;
+                right += pattern_len;
+                if !remove_all {
+                    break;
+                }
+            } else {
+                result.push(input[left]);
+                left += 1;
+                right += 1;
+            }
+        }
+        // append the remaing thing to result, this can happened when
+        // we have something to remove and remove_all is False.
+        let mut remain = input[left..].to_vec();
+        result.append(&mut remain);
+        Value::Binary { val: result, span }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesRemove {})
+    }
+}

crates/nu-command/src/bytes/replace.rs

@@ -0,0 +1,187 @@
+use crate::input_handler::{operate, CmdArgument};
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type,
+    Value,
+};
+
+struct Arguments {
+    find: Vec<u8>,
+    replace: Vec<u8>,
+    cell_paths: Option<Vec<CellPath>>,
+    all: bool,
+}
+
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
+    }
+}
+
+#[derive(Clone)]
+pub struct BytesReplace;
+
+impl Command for BytesReplace {
+    fn name(&self) -> &str {
+        "bytes replace"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes replace")
+            .input_output_types(vec![(Type::Binary, Type::Binary)])
+            .required("find", SyntaxShape::Binary, "the pattern to find")
+            .required("replace", SyntaxShape::Binary, "the replacement pattern")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "for a data structure input, replace bytes in data at the given cell paths",
+            )
+            .switch("all", "replace all occurrences of find binary", Some('a'))
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Find and replace binary"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["search", "shift", "switch"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 2)?;
+        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let find = call.req::<Spanned<Vec<u8>>>(engine_state, stack, 0)?;
+        if find.item.is_empty() {
+            return Err(ShellError::UnsupportedInput(
+                "the pattern to find cannot be empty".to_string(),
+                find.span,
+            ));
+        }
+
+        let arg = Arguments {
+            find: find.item,
+            replace: call.req::<Vec<u8>>(engine_state, stack, 1)?,
+            cell_paths,
+            all: call.has_flag("all"),
+        };
+
+        operate(replace, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Find and replace contents",
+                example: "0x[10 AA FF AA FF] | bytes replace 0x[10 AA] 0x[FF]",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xFF, 0xAA, 0xFF],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Find and replace all occurrences of find binary",
+                example: "0x[10 AA 10 BB 10] | bytes replace -a 0x[10] 0x[A0]",
+                result: Some(Value::Binary {
+                    val: vec![0xA0, 0xAA, 0xA0, 0xBB, 0xA0],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Find and replace all occurrences of find binary in table",
+                example: "[[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes replace -a 0x[11] 0x[13] ColA ColC",
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::Binary {
+                                val: vec![0x13, 0x12, 0x13],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x14, 0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x17, 0x18, 0x19],
+                                span: Span::test_data(),
+                            },
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn replace(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => replace_impl(val, args, *val_span),
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+fn replace_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    let mut replaced = vec![];
+    let replace_all = arg.all;
+
+    // doing find-and-replace stuff.
+    let (mut left, mut right) = (0, arg.find.len());
+    let input_len = input.len();
+    let pattern_len = arg.find.len();
+    while right <= input_len {
+        if input[left..right] == arg.find {
+            let mut to_replace = arg.replace.clone();
+            replaced.append(&mut to_replace);
+            left += pattern_len;
+            right += pattern_len;
+            if !replace_all {
+                break;
+            }
+        } else {
+            replaced.push(input[left]);
+            left += 1;
+            right += 1;
+        }
+    }
+
+    let mut remain = input[left..].to_vec();
+    replaced.append(&mut remain);
+    Value::Binary {
+        val: replaced,
+        span,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesReplace {})
+    }
+}

crates/nu-command/src/bytes/reverse.rs

@@ -0,0 +1,106 @@
+use crate::input_handler::{operate, CellPathOnlyArgs};
+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;
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
+
+#[derive(Clone)]
+
+pub struct BytesReverse;
+
+impl Command for BytesReverse {
+    fn name(&self) -> &str {
+        "bytes reverse"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes reverse")
+            .input_output_types(vec![(Type::Binary, Type::Binary)])
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "for a data structure input, reverse data at the given cell paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Reverse the bytes in the pipeline"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["convert", "inverse", "flip"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+        let arg = CellPathOnlyArgs::from(cell_paths);
+        operate(reverse, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Reverse bytes `0x[1F FF AA AA]`",
+                example: "0x[1F FF AA AA] | bytes reverse",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0xAA, 0xFF, 0x1F],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Reverse bytes `0x[FF AA AA]`",
+                example: "0x[FF AA AA] | bytes reverse",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0xAA, 0xFF],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn reverse(val: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => {
+            let mut reversed_input = val.to_vec();
+            reversed_input.reverse();
+            Value::Binary {
+                val: reversed_input,
+                span: *val_span,
+            }
+        }
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesReverse {})
+    }
+}

crates/nu-command/src/bytes/starts_with.rs

@@ -0,0 +1,133 @@
+use crate::input_handler::{operate, CmdArgument};
+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;
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    cell_paths: Option<Vec<CellPath>>,
+}
+
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
+    }
+}
+
+#[derive(Clone)]
+
+pub struct BytesStartsWith;
+
+impl Command for BytesStartsWith {
+    fn name(&self) -> &str {
+        "bytes starts-with"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes starts-with")
+            .input_output_types(vec![(Type::Binary, Type::Bool)])
+            .required("pattern", SyntaxShape::Binary, "the pattern to match")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "for a data structure input, check if bytes at the given cell paths start with the pattern",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Check if bytes starts with a pattern"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["pattern", "match", "find", "search"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let arg = Arguments {
+            pattern,
+            cell_paths,
+        };
+        operate(
+            starts_with,
+            arg,
+            input,
+            call.head,
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Checks if binary starts with `0x[1F FF AA]`",
+                example: "0x[1F FF AA AA] | bytes starts-with 0x[1F FF AA]",
+                result: Some(Value::Bool {
+                    val: true,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Checks if binary starts with `0x[1F]`",
+                example: "0x[1F FF AA AA] | bytes starts-with 0x[1F]",
+                result: Some(Value::Bool {
+                    val: true,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Checks if binary starts with `0x[1F]`",
+                example: "0x[1F FF AA AA] | bytes starts-with 0x[11]",
+                result: Some(Value::Bool {
+                    val: false,
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn starts_with(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => Value::Bool {
+            val: val.starts_with(&args.pattern),
+            span: *val_span,
+        },
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesStartsWith {})
+    }
+}