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

@@ -12,3 +12,17 @@ rustflags = ["-C", "link-args=-stack:10000000", "-C", "target-feature=+crt-stati
 # 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,17 +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.)_
 
-Make sure you've done the following:
+# User-Facing Changes
 
-- [ ] Add tests that cover your changes, either in the command examples, the crate/tests folder, or in the /tests folder.
-- [ ] Try to think about corner cases and various ways how your changes could break. Cover them with tests.
-- [ ] If adding tests is not possible, please document in the PR body a minimal example with steps on how to reproduce so one can verify your change works.
+_(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 --features=extra -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect` to check that you're using the standard code style
-- [ ] `cargo test --workspace --features=extra` 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

@@ -20,31 +20,22 @@ jobs:
       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
-
-      - uses: Swatinem/rust-cache@v1
-        with:
-          key: "v2" # increment this to bust the cache if needed
+      - 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: --features=extra --workspace --exclude nu_plugin_* -- -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
 
   nu-tests:
     env:
@@ -54,40 +45,31 @@ jobs:
       fail-fast: true
       matrix:
         platform: [windows-latest, macos-latest, ubuntu-latest]
-        style: [extra, default]
+        style: [default, dataframe]
         rust:
           - stable
         include:
-          - style: extra
-            flags: "--features=extra"
           - style: default
             flags: ""
+          - style: dataframe
+            flags: "--features=dataframe"
         exclude:
+          # only test dataframes on Ubuntu (the fastest platform)
           - platform: windows-latest
-            style: default
+            style: dataframe
           - platform: macos-latest
-            style: default
+            style: dataframe
 
     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
-
-      # Temporarily disabled; the cache was getting huge (2.6GB compressed) on Windows and causing issues.
-      # TODO: investigate why the cache was so big
-      # - uses: Swatinem/rust-cache@v1
-      #   with:
-      #     key: ${{ matrix.style }}v3 # increment this to bust the cache if needed
+      - 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: --workspace --profile ci --exclude nu_plugin_* ${{ matrix.flags }}
@@ -108,37 +90,26 @@ 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
-
-      - uses: Swatinem/rust-cache@v1
-        with:
-          key: "2" # increment this to bust the cache if needed
+      - 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=. --profile ci --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
@@ -161,23 +132,19 @@ 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
+      - name: Setup Rust toolchain and cache
+        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
 
       - name: Clippy
-        uses: actions-rs/cargo@v1
+        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
+        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

@@ -41,7 +41,7 @@ if $os in ['ubuntu-latest', 'macos-latest'] {
     } else {
         # musl-tools to fix 'Failed to find tool. Is `musl-gcc` installed?'
         # Actually just for x86_64-unknown-linux-musl target
-        sudo apt install musl-tools -y
+        if $os == 'ubuntu-latest' { sudo apt install musl-tools -y }
         cargo-build-nu $flags
     }
 }
@@ -50,10 +50,10 @@ if $os in ['ubuntu-latest', 'macos-latest'] {
 # Build for Windows without static-link-openssl feature
 # ----------------------------------------------------------------------------
 if $os in ['windows-latest'] {
-    if ($flags | str trim | empty?) {
-        cargo build --release --all --target $target --features=extra
+    if ($flags | str trim | is-empty) {
+        cargo build --release --all --target $target
     } else {
-        cargo build --release --all --target $target --features=extra $flags
+        cargo build --release --all --target $target $flags
     }
 }
 
@@ -76,11 +76,11 @@ cp -v README.release.txt $'($dist)/README.txt'
 
 $'(char nl)Check binary release version detail:'; hr-line
 let ver = if $os == 'windows-latest' {
-    (do -i { ./output/nu.exe -c 'version' }) | str collect
+    (do -i { ./output/nu.exe -c 'version' }) | str join
 } else {
-    (do -i { ./output/nu -c 'version' }) | str collect
+    (do -i { ./output/nu -c 'version' }) | str join
 }
-if ($ver | str trim | empty?) {
+if ($ver | str trim | is-empty) {
     $'(ansi r)Incompatible nu binary...(ansi reset)'
 } else { $ver }
 
@@ -90,10 +90,16 @@ if ($ver | str trim | empty?) {
 cd $dist; $'(char nl)Creating release archive...'; hr-line
 if $os in ['ubuntu-latest', 'macos-latest'] {
 
-    $'(char nl)(ansi g)Archive contents:(ansi reset)'; hr-line; ls
+    let files = (ls | get name)
+    let dest = $'($bin)-($version)-($target)'
+    let archive = $'($dist)/($dest).tar.gz'
 
-    let archive = $'($dist)/($bin)-($version)-($target).tar.gz'
-    tar czf $archive *
+    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)'
 
@@ -102,7 +108,7 @@ if $os in ['ubuntu-latest', 'macos-latest'] {
     let releaseStem = $'($bin)-($version)-($target)'
 
     $'(char nl)Download less related stuffs...'; hr-line
-    aria2c https://github.com/jftuga/less-Windows/releases/download/less-v590/less.exe -o less.exe
+    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
@@ -113,7 +119,7 @@ if $os in ['ubuntu-latest', 'macos-latest'] {
         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.2
+        cargo install cargo-wix --version 0.3.3
         cargo wix --no-build --nocapture --package nu --output $wixRelease
         echo $'::set-output name=archive::($wixRelease)'
 
@@ -124,17 +130,17 @@ if $os in ['ubuntu-latest', 'macos-latest'] {
         7z a $archive *
         print $'archive: ---> ($archive)';
         let pkg = (ls -f $archive | get name)
-        if not ($pkg | empty?) {
+        if not ($pkg | is-empty) {
             echo $'::set-output name=archive::($pkg | get 0)'
         }
     }
 }
 
 def 'cargo-build-nu' [ options: string ] {
-    if ($options | str trim | empty?) {
-        cargo build --release --all --target $target --features=extra,static-link-openssl
+    if ($options | str trim | is-empty) {
+        cargo build --release --all --target $target --features=static-link-openssl
     } else {
-        cargo build --release --all --target $target --features=extra,static-link-openssl $options
+        cargo build --release --all --target $target --features=static-link-openssl $options
     }
 }
 
@@ -143,7 +149,7 @@ def 'hr-line' [
     --blank-line(-b): bool
 ] {
     print $'(ansi g)---------------------------------------------------------------------------->(ansi reset)'
-    if $blank-line { char nl }
+    if $blank_line { char nl }
 }
 
 # Get the specified env key's value or ''

.github/workflows/release.yml

@@ -70,9 +70,9 @@ jobs:
         target: ${{ matrix.target }}
 
     - name: Setup Nushell
-      uses: hustcer/setup-nu@v1
+      uses: hustcer/setup-nu@v2.1
       with:
-        version: 0.63.0
+        version: 0.69.1
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -88,7 +88,7 @@ jobs:
 
     # REF: https://github.com/marketplace/actions/gh-release
     - name: Publish Archive
-      uses: softprops/action-gh-release@v1
+      uses: softprops/action-gh-release@v0.1.13
       if: ${{ startsWith(github.ref, 'refs/tags/') }}
       with:
         draft: true

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

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

CONTRIBUTING.md

@@ -1,8 +1,23 @@
 # Contributing
 
-Welcome to Nushell!
+Welcome to Nushell and thank you for considering contributing!
 
-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)!
+## Review Process
+
+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.
+
+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
 
@@ -16,6 +31,18 @@ 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:
@@ -24,21 +51,21 @@ cargo build
   cargo run
   ```
 
-- Build and run with extra features. Currently extra features include dataframes and sqlite database support.
+- Build and run with dataframe support.
   ```shell
-  cargo run --features=extra
+  cargo run --features=dataframe
   ```
 
 - Run Clippy on Nushell:
 
   ```shell
-  cargo clippy --workspace --features=extra -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
+  cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
   ```
 
 - Run all tests:
 
   ```shell
-  cargo test --workspace --features=extra
+  cargo test --workspace
   ```
 
 - Run all tests for a specific command
@@ -64,5 +91,11 @@ cargo build
 - To view verbose logs when developing, enable the `trace` log level.
 
   ```shell
-  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.60"
-version = "0.65.0"
+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,59 +34,69 @@ members = [
 	"crates/nu_plugin_gstat",
 	"crates/nu_plugin_example",
 	"crates/nu_plugin_query",
+	"crates/nu_plugin_custom_values",
 	"crates/nu-utils",
 ]
 
 [dependencies]
-chrono = { version = "0.4.19", features = ["serde"] }
-crossterm = "0.23.0"
+chrono = { version = "0.4.23", features = ["serde"] }
+crossterm = "0.24.0"
 ctrlc = "3.2.1"
 log = "0.4"
-miette = "5.1.0"
+miette = { version = "5.1.0", features = ["fancy-no-backtrace"] }
 nu-ansi-term = "0.46.0"
-nu-cli = { path="./crates/nu-cli", version = "0.65.0"  }
-nu-color-config = { path = "./crates/nu-color-config", version = "0.65.0"  }
-nu-command = { path="./crates/nu-command", version = "0.65.0"  }
-nu-engine = { path="./crates/nu-engine", version = "0.65.0"  }
-nu-json = { path="./crates/nu-json", version = "0.65.0"  }
-nu-parser = { path="./crates/nu-parser", version = "0.65.0"  }
-nu-path = { path="./crates/nu-path", version = "0.65.0"  }
-nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.65.0"  }
-nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.65.0"  }
-nu-protocol = { path = "./crates/nu-protocol", version = "0.65.0"  }
-nu-system = { path = "./crates/nu-system", version = "0.65.0" }
-nu-table = { path = "./crates/nu-table", version = "0.65.0"  }
-nu-term-grid = { path = "./crates/nu-term-grid", version = "0.65.0"  }
-nu-utils = { path = "./crates/nu-utils", version = "0.65.0"  }
-reedline = { version = "0.8.0", features = ["bashisms", "sqlite"]}
-pretty_env_logger = "0.4.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"
 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 }
 
-[dev-dependencies]
-nu-test-support = { path="./crates/nu-test-support", version = "0.65.0"  }
-tempfile = "3.2.0"
-assert_cmd = "2.0.2"
-pretty_assertions = "1.0.0"
-serial_test = "0.5.1"
-hamcrest2 = "0.3.0"
-rstest = "0.12.0"
-itertools = "0.10.3"
 
 [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.72.0"  }
+tempfile = "3.2.0"
+assert_cmd = "2.0.2"
+pretty_assertions = "1.0.0"
+serial_test = "0.8.0"
+hamcrest2 = "0.3.0"
+rstest = {version = "0.15.0", default-features = false}
+itertools = "0.10.3"
+
 [features]
 plugin = ["nu-plugin", "nu-cli/plugin", "nu-parser/plugin", "nu-command/plugin", "nu-protocol/plugin", "nu-engine/plugin"]
-default = ["plugin", "which-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", "database"]
 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"]
 
@@ -93,8 +109,8 @@ trash-support = ["nu-command/trash-support"]
 # Dataframe feature for nushell
 dataframe = ["nu-command/dataframe"]
 
-# Database commands for nushell
-database = ["nu-command/database"]
+# SQLite commands for nushell
+sqlite = ["nu-command/sqlite"]
 
 [profile.release]
 opt-level = "s" # Optimize for size
@@ -119,3 +135,8 @@ debug = false
 [[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" }

README.md

@@ -71,7 +71,7 @@ Additionally, commands can output structured data (you can think of this as a th
 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 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.
@@ -206,7 +206,7 @@ Nu is under heavy development and will naturally change as it matures. The chart
 | 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
 

README.release.txt

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

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 {

crates/nu-cli/Cargo.toml

@@ -1,33 +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.65.0"
+version = "0.72.0"
 
 [dev-dependencies]
-nu-test-support = { path="../nu-test-support", version = "0.65.0"  }
-nu-command = { path = "../nu-command", version = "0.65.0" }
+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.65.0"  }
-nu-path = { path = "../nu-path", version = "0.65.0"  }
-nu-parser = { path = "../nu-parser", version = "0.65.0"  }
-nu-protocol = { path = "../nu-protocol", version = "0.65.0"  }
-nu-utils = { path = "../nu-utils", version = "0.65.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.65.0"  }
-reedline = { version = "0.8.0", features = ["bashisms", "sqlite"]}
-crossterm = "0.23.0"
-miette = { version = "5.1.0", features = ["fancy"] }
-thiserror = "1.0.31"
-fuzzy-matcher = "0.3.7"
+nu-color-config = { path = "../nu-color-config", version = "0.72.0"  }
+reedline = { version = "0.14.0", features = ["bashisms", "sqlite"]}
 
-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"
-chrono = "0.4.19"
-sysinfo = "0.24.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

@@ -5,21 +5,26 @@ use nu_engine::{convert_env_values, eval_block};
 use nu_parser::parse;
 use nu_protocol::engine::Stack;
 use nu_protocol::{
-    engine::{EngineState, StateDelta, StateWorkingSet},
+    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,
     table_mode: Option<Value>,
 ) -> Result<Option<i64>> {
-    // Run a command (or commands) given to us by the user
+    // 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();
@@ -39,43 +44,19 @@ 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 mut config = engine_state.get_config().clone();
-    if let Some(t_mode) = table_mode {
-        config.table_mode = t_mode.as_string()?;
-    }
-
-    // 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(engine_state), 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);
-    }
-
+    // Run the block
     let exit_code = match eval_block(engine_state, stack, &block, input, false, false) {
         Ok(pipeline_data) => {
+            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) => {
@@ -86,9 +67,7 @@ pub fn evaluate_commands(
         }
     };
 
-    if is_perf_true {
-        info!("evaluate {}:{}:{}", file!(), line!(), column!());
-    }
+    info!("evaluate {}:{}:{}", file!(), line!(), column!());
 
     Ok(exit_code)
 }

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

@@ -11,6 +11,7 @@ pub struct CommandCompletion {
     engine_state: Arc<EngineState>,
     flattened: Vec<(Span, FlatShape)>,
     flat_shape: FlatShape,
+    force_completion_after_space: bool,
 }
 
 impl CommandCompletion {
@@ -19,11 +20,13 @@ impl CommandCompletion {
         _: &StateWorkingSet,
         flattened: Vec<(Span, FlatShape)>,
         flat_shape: FlatShape,
+        force_completion_after_space: bool,
     ) -> Self {
         Self {
             engine_state,
             flattened,
             flat_shape,
+            force_completion_after_space,
         }
     }
 
@@ -43,19 +46,21 @@ impl CommandCompletion {
 
                     if let Ok(mut contents) = std::fs::read_dir(path) {
                         while let Some(Ok(item)) = contents.next() {
-                            if !executables.contains(
-                                &item
-                                    .path()
-                                    .file_name()
-                                    .map(|x| x.to_string_lossy().to_string())
-                                    .unwrap_or_default(),
-                            ) && matches!(
-                                item.path()
-                                    .file_name()
-                                    .map(|x| match_algorithm
+                            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| match_algorithm
                                         .matches_str(&x.to_string_lossy(), prefix)),
-                                Some(true)
-                            ) && is_executable::is_executable(&item.path())
+                                    Some(true)
+                                )
+                                && is_executable::is_executable(item.path())
                             {
                                 if let Ok(name) = item.file_name().into_string() {
                                     executables.push(name);
@@ -114,7 +119,8 @@ impl CommandCompletion {
 
         let partial = working_set.get_span_contents(span);
         let partial = String::from_utf8_lossy(partial).to_string();
-        let results = if find_externals {
+
+        if find_externals {
             let results_external = self
                 .external_command_completion(&partial, match_algorithm)
                 .into_iter()
@@ -146,9 +152,7 @@ impl CommandCompletion {
             results
         } else {
             results
-        };
-
-        results
+        }
     }
 }
 
@@ -205,6 +209,10 @@ impl Completer for CommandCompletion {
             || ((span.end - span.start) == 0)
         {
             // we're in a gap or at a command
+            if working_set.get_span_contents(span).is_empty() && !self.force_completion_after_space
+            {
+                return vec![];
+            }
             self.complete_commands(
                 working_set,
                 span,

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

@@ -2,10 +2,12 @@ use crate::completions::{
     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,
+    BlockId, PipelineData, Span, Value,
 };
 use reedline::{Completer as ReedlineCompleter, Suggestion};
 use std::str;
@@ -56,176 +58,136 @@ impl NuCompleter {
         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 new_line, alias_offset) = try_find_alias(line.as_bytes(), &working_set);
         let initial_line = line.to_string();
-        new_line.push(b'a');
+        let alias_total_offset: usize = alias_offset.iter().sum();
+        new_line.insert(alias_total_offset + pos, b'a');
         let pos = offset + pos;
+        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 {
-                let flattened: Vec<_> = flatten_expression(&working_set, &expr);
-                let span_offset: usize = alias_offset.iter().sum();
+            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 + 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());
+                        for (flat_idx, flat) in flattened.iter().enumerate() {
+                            // 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);
 
-                        // Create a new span
-                        let new_span = if flat_idx == 0 {
-                            Span {
-                                start: flat.0.start,
-                                end: flat.0.end - 1 - span_offset,
+                            // 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());
                             }
-                        } else {
-                            Span {
-                                start: flat.0.start - span_offset,
-                                end: flat.0.end - 1 - span_offset,
-                            }
-                        };
 
-                        // Parses the prefix
-                        let mut prefix = working_set.get_span_contents(flat.0).to_vec();
-                        prefix.remove(pos - (flat.0.start - span_offset));
+                            // 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());
 
-                        // Variables completion
-                        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![])),
-                            );
+                                // Create a new span
+                                let new_span = if flat_idx == 0 {
+                                    Span {
+                                        start: flat.0.start,
+                                        end: flat.0.end - 1 - span_offset,
+                                    }
+                                } else {
+                                    Span {
+                                        start: flat.0.start - span_offset,
+                                        end: flat.0.end - 1 - span_offset,
+                                    }
+                                };
 
-                            return self.process_completion(
-                                &mut completer,
-                                &working_set,
-                                prefix,
-                                new_span,
-                                offset,
-                                pos,
-                            );
-                        }
+                                // 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();
+                                let index = pos - (flat.0.start - span_offset);
+                                prefix.drain(index..);
 
-                        // Flags completion
-                        if prefix.starts_with(b"-") {
-                            let mut completer = FlagCompletion::new(expr);
-
-                            return self.process_completion(
-                                &mut completer,
-                                &working_set,
-                                prefix,
-                                new_span,
-                                offset,
-                                pos,
-                            );
-                        }
-
-                        // Completions that depends on the previous expression (e.g: use, source)
-                        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" {
-                                    let mut completer =
-                                        DotNuCompletion::new(self.engine_state.clone());
-
-                                    return self.process_completion(
-                                        &mut completer,
-                                        &working_set,
-                                        prefix,
-                                        new_span,
-                                        offset,
-                                        pos,
+                                // Variables completion
+                                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![])),
                                     );
-                                } 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(),
-                                    *decl_id,
-                                    initial_line,
-                                );
-
-                                return self.process_completion(
-                                    &mut completer,
-                                    &working_set,
-                                    prefix,
-                                    new_span,
-                                    offset,
-                                    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());
-
-                                return self.process_completion(
-                                    &mut completer,
-                                    &working_set,
-                                    prefix,
-                                    new_span,
-                                    offset,
-                                    pos,
-                                );
-                            }
-                            flat_shape => {
-                                let mut completer = CommandCompletion::new(
-                                    self.engine_state.clone(),
-                                    &working_set,
-                                    flattened.clone(),
-                                    // flat_idx,
-                                    flat_shape.clone(),
-                                );
-
-                                let out: Vec<_> = self.process_completion(
-                                    &mut completer,
-                                    &working_set,
-                                    prefix.clone(),
-                                    new_span,
-                                    offset,
-                                    pos,
-                                );
-
-                                if out.is_empty() {
-                                    let mut completer =
-                                        FileCompletion::new(self.engine_state.clone());
 
                                     return self.process_completion(
                                         &mut completer,
@@ -237,15 +199,195 @@ impl NuCompleter {
                                     );
                                 }
 
-                                return out;
+                                // Flags completion
+                                if prefix.starts_with(b"-") {
+                                    // 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,
+                                        prefix,
+                                        new_span,
+                                        offset,
+                                        pos,
+                                    );
+                                }
+
+                                // 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(),
+                                            *decl_id,
+                                            initial_line,
+                                        );
+
+                                        return self.process_completion(
+                                            &mut completer,
+                                            &working_set,
+                                            prefix,
+                                            new_span,
+                                            offset,
+                                            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());
+
+                                        return self.process_completion(
+                                            &mut completer,
+                                            &working_set,
+                                            prefix,
+                                            new_span,
+                                            offset,
+                                            pos,
+                                        );
+                                    }
+                                    flat_shape => {
+                                        let mut completer = CommandCompletion::new(
+                                            self.engine_state.clone(),
+                                            &working_set,
+                                            flattened.clone(),
+                                            // flat_idx,
+                                            flat_shape.clone(),
+                                            false,
+                                        );
+
+                                        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,
+                                            new_span,
+                                            offset,
+                                            pos,
+                                        );
+
+                                        if !out.is_empty() {
+                                            return out;
+                                        }
+                                    }
+                                };
                             }
-                        };
+                        }
                     }
                 }
             }
         }
 
-        return vec![];
+        vec![]
     }
 }
 
@@ -302,7 +444,7 @@ fn search_alias(input: &[u8], working_set: &StateWorkingSet) -> Option<MatchedAl
     }
     // Push the rest to names vector.
     if pos < input.len() {
-        vec_names.push((&input[pos..]).to_owned());
+        vec_names.push(input[pos..].to_owned());
     }
 
     for name in &vec_names {
@@ -383,3 +525,65 @@ fn most_left_variable(
 
     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/custom_completions.rs

@@ -8,6 +8,8 @@ use nu_protocol::{
 use reedline::Suggestion;
 use std::sync::Arc;
 
+use super::completer::map_value_completions;
+
 pub struct CustomCompletion {
     engine_state: Arc<EngineState>,
     stack: Stack,
@@ -26,69 +28,6 @@ impl CustomCompletion {
             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| {
-            // 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()
-    }
 }
 
 impl Completer for CustomCompletion {
@@ -144,7 +83,7 @@ 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");
@@ -189,7 +128,7 @@ impl Completer for CustomCompletion {
 
                         completions
                     }
-                    Value::List { vals, .. } => self.map_completions(vals.iter(), span, offset),
+                    Value::List { vals, .. } => map_value_completions(vals.iter(), span, offset),
                     _ => vec![],
                 }
             }

crates/nu-cli/src/config_files.rs

@@ -1,7 +1,13 @@
 use crate::util::{eval_source, report_error};
 #[cfg(feature = "plugin")]
 use log::info;
-use nu_protocol::engine::{EngineState, Stack, StateDelta, StateWorkingSet};
+#[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;
 
@@ -15,16 +21,16 @@ const HISTORY_FILE_SQLITE: &str = "history.sqlite3";
 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(
@@ -37,14 +43,27 @@ pub fn read_plugin_file(
         }
     }
 
-    if is_perf_true {
-        info!("read_plugin_file {}:{}:{}", file!(), line!(), column!());
-    }
+    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);
@@ -58,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(
@@ -69,12 +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(engine_state), 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);
                     }

crates/nu-cli/src/eval_file.rs

@@ -19,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) {
@@ -30,6 +29,8 @@ 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);
 
@@ -54,9 +55,7 @@ pub fn evaluate_file(
         std::process::exit(1);
     }
 
-    if is_perf_true {
-        info!("evaluate {}:{}:{}", file!(), line!(), column!());
-    }
+    info!("evaluate {}:{}:{}", file!(), line!(), column!());
 
     Ok(())
 }
@@ -75,56 +74,43 @@ pub fn print_table_or_error(
     // 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(
-                engine_state,
-                stack,
-                &Call::new(Span::new(0, 0)),
-                pipeline_data,
-            );
+            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)),
+                    pipeline_data,
+                );
 
-            match table {
-                Ok(table) => {
-                    for item in table {
-                        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');
-
-                        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
+                match table {
+                    Ok(table) => {
+                        print_or_exit(table, engine_state, config);
                     }
-                }
-                Err(error) => {
-                    let working_set = StateWorkingSet::new(engine_state);
+                    Err(error) => {
+                        let working_set = StateWorkingSet::new(engine_state);
 
-                    report_error(&working_set, &error);
+                        report_error(&working_set, &error);
 
-                    std::process::exit(1);
+                        std::process::exit(1);
+                    }
                 }
             }
         }
         None => {
-            for item in pipeline_data {
-                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');
-
-                let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
-            }
+            print_or_exit(pipeline_data, engine_state, config);
         }
     };
 
@@ -141,3 +127,20 @@ pub fn print_table_or_error(
         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);
+
+            report_error(&working_set, &error);
+
+            std::process::exit(1);
+        }
+
+        let mut out = item.into_string("\n", config);
+        out.push('\n');
+
+        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
+    }
+}

crates/nu-cli/src/lib.rs

@@ -22,8 +22,9 @@ 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::{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,
     },
 };
 
@@ -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 => {
@@ -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

@@ -17,7 +17,7 @@ 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
@@ -31,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)
@@ -39,7 +39,7 @@ impl NuHelpCompleter {
 
         commands
             .into_iter()
-            .map(|(sig, examples, _, _)| {
+            .map(|(sig, examples, _, _, _)| {
                 let mut long_desc = String::new();
 
                 let usage = &sig.usage;

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!()
-                    );
+                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!());
-    }
+    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]),
         ]),
     );
 
@@ -666,6 +666,7 @@ fn add_parsed_keybinding(
 
             KeyCode::Char(char)
         }
+        "space" => KeyCode::Char(' '),
         "down" => KeyCode::Down,
         "up" => KeyCode::Up,
         "left" => KeyCode::Left,
@@ -814,7 +815,6 @@ 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,
@@ -822,6 +822,8 @@ fn event_from_record(
         "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,
@@ -962,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 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,166 +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::Directory => output.push((
-                    // nushell Directory
-                    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;
         }
@@ -216,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,11 +1,11 @@
-use log::trace;
+use crate::repl::eval_hook;
 use nu_engine::eval_block;
 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::{
     engine::{EngineState, Stack},
-    PipelineData, ShellError, Span, Value,
+    print_if_stream, PipelineData, ShellError, Span, Value,
 };
 #[cfg(windows)]
 use nu_utils::enable_vt_processing;
@@ -204,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(
@@ -224,35 +222,48 @@ pub fn eval_source(
         (output, working_set.render())
     };
 
-    let cwd = 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()
-        }
-    };
-
-    let _ = engine_state.merge_delta(delta, Some(stack), &cwd);
+    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) = pipeline_data.print(engine_state, stack, false, false) {
-                let working_set = StateWorkingSet::new(engine_state);
+            match result {
+                Err(err) => {
+                    let working_set = StateWorkingSet::new(engine_state);
 
-                report_error(&working_set, &err);
+                    report_error(&working_set, &err);
 
-                return false;
+                    return false;
+                }
+                Ok(exit_code) => {
+                    set_last_exit_code(stack, exit_code);
+                }
             }
 
             // reset vt processing, aka ansi because illbehaved externals can break it
@@ -297,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,
@@ -310,6 +330,17 @@ 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::*;

crates/nu-cli/tests/alias.rs

@@ -1,65 +0,0 @@
-pub mod support;
-
-use nu_cli::NuCompleter;
-use reedline::Completer;
-use support::{match_suggestions, new_engine};
-
-#[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)
-}

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/custom_completions.rs

@@ -1,29 +0,0 @@
-pub mod support;
-
-use nu_cli::NuCompleter;
-use reedline::Completer;
-use support::{match_suggestions, new_engine};
-
-#[test]
-fn variables_completions() {
-    // 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
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    // Test completions for $nu
-    let suggestions = completer.complete("my-command ", 11);
-
-    assert_eq!(3, suggestions.len());
-
-    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
-
-    // Match results
-    match_suggestions(expected, suggestions);
-}

crates/nu-cli/tests/dotnu_completions.rs

@@ -1,28 +0,0 @@
-pub mod support;
-
-use nu_cli::NuCompleter;
-use reedline::Completer;
-use support::new_engine;
-
-#[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 ".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);
-}

crates/nu-cli/tests/file_completions.rs

@@ -1,272 +0,0 @@
-pub mod support;
-
-use nu_cli::NuCompleter;
-use reedline::Completer;
-use support::{file, folder, match_suggestions, new_engine};
-
-#[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 the completions/another folder
-    let target_dir = format!("cd {}", 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_completion() {
-    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_completion() {
-    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_completion() {
-    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_completion() {
-    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_completion() {
-    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_completion() {
-    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_completion() {
-    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)
-}

crates/nu-cli/tests/flag_completions.rs

@@ -1,36 +0,0 @@
-pub mod support;
-
-use nu_cli::NuCompleter;
-use reedline::Completer;
-use support::{match_suggestions, new_engine};
-
-#[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!(12, suggestions.len());
-
-    let expected: Vec<String> = vec![
-        "--all".into(),
-        "--du".into(),
-        "--full-paths".into(),
-        "--help".into(),
-        "--long".into(),
-        "--short-names".into(),
-        "-a".into(),
-        "-d".into(),
-        "-f".into(),
-        "-h".into(),
-        "-l".into(),
-        "-s".into(),
-    ];
-
-    // Match results
-    match_suggestions(expected, suggestions);
-}

crates/nu-cli/tests/folder_completions.rs

@@ -1,29 +0,0 @@
-pub mod support;
-
-use nu_cli::NuCompleter;
-use reedline::Completer;
-use support::{folder, match_suggestions, new_engine};
-
-#[test]
-fn folder_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!("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);
-}

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

@@ -4,7 +4,7 @@ use nu_command::create_default_context;
 use nu_engine::eval_block;
 use nu_parser::parse;
 use nu_protocol::{
-    engine::{EngineState, Stack, StateDelta, StateWorkingSet},
+    engine::{EngineState, Stack, StateWorkingSet},
     PipelineData, ShellError, Span, Value,
 };
 use nu_test_support::fs;
@@ -23,14 +23,11 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
     dir_str.push(SEP);
 
     // Create a new engine with default context
-    let mut engine_state = create_default_context(&dir);
+    let mut engine_state = create_default_context();
 
     // New stack
     let mut stack = Stack::new();
 
-    // New delta state
-    let delta = StateDelta::new(&engine_state);
-
     // Add pwd as env var
     stack.add_env_var(
         "PWD".to_string(),
@@ -53,8 +50,8 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
         },
     );
 
-    // Merge delta
-    let merge_result = engine_state.merge_delta(delta, Some(&mut stack), &dir);
+    // 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)
@@ -62,6 +59,15 @@ pub fn new_engine() -> (PathBuf, String, EngineState, 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);
     });
@@ -97,6 +103,9 @@ pub fn merge_input(
 
         (block, working_set.render())
     };
+
+    engine_state.merge_delta(delta)?;
+
     assert!(eval_block(
         engine_state,
         stack,
@@ -112,6 +121,6 @@ pub fn merge_input(
     )
     .is_ok());
 
-    // Merge delta
-    engine_state.merge_delta(delta, Some(stack), &dir)
+    // Merge environment into the permanent state
+    engine_state.merge_env(stack, &dir)
 }

crates/nu-cli/tests/variables_completions.rs

@@ -1,88 +0,0 @@
-pub mod support;
-
-use nu_cli::NuCompleter;
-use reedline::Completer;
-use support::{match_suggestions, new_engine};
-
-#[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);
-}

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.65.0"
+version = "0.72.0"
 
 [dependencies]
-nu-protocol = { path = "../nu-protocol", version = "0.65.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.72.0"  }
 nu-ansi-term = "0.46.0"
-nu-json = { path = "../nu-json", version = "0.65.0"  }
-nu-table = { path = "../nu-table", version = "0.65.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

@@ -217,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

@@ -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

@@ -34,6 +34,10 @@ pub fn get_shape_color(shape: String, conf: &Config) -> Style {
             "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,29 +1,30 @@
 [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.65.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.65.0"  }
-nu-engine = { path = "../nu-engine", version = "0.65.0"  }
-nu-glob = { path = "../nu-glob", version = "0.65.0" }
-nu-json = { path = "../nu-json", version = "0.65.0"  }
-nu-parser = { path = "../nu-parser", version = "0.65.0"  }
-nu-path = { path = "../nu-path", version = "0.65.0"  }
-nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.65.0"  }
-nu-protocol = { path = "../nu-protocol", version = "0.65.0"  }
-nu-system = { path = "../nu-system", version = "0.65.0"  }
-nu-table = { path = "../nu-table", version = "0.65.0"  }
-nu-term-grid = { path = "../nu-term-grid", version = "0.65.0"  }
-nu-test-support = { path = "../nu-test-support", version = "0.65.0"  }
-nu-utils = { path = "../nu-utils", version = "0.65.0" }
+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"
@@ -31,16 +32,17 @@ 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.1"
-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"
@@ -52,68 +54,90 @@ 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"
-powierza-coefficient = "1.0"
-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"
 # Disable default features b/c the default features build Git (very slow to compile)
-shadow-rs = { version = "0.11.0", default-features = false }
-strip-ansi-escapes = "0.1.1"
-sysinfo = "0.23.5"
-terminal_size = "0.1.17"
+shadow-rs = { version = "0.16.1", default-features = false }
+sysinfo = "0.26.2"
+terminal_size = "0.2.1"
 thiserror = "1.0.31"
-titlecase = "1.1.0"
+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.8.0", features = ["bashisms", "sqlite"]}
-wax = { version =  "0.4.0", features = ["diagnostics"] }
-rusqlite = { version = "0.27.0", features = ["bundled"], optional = true }
-sqlparser = { version = "0.16.0", features = ["serde"], 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 = "2.0.0"
 users = "0.11.0"
-signal-hook = { version = "0.3.14", default-features = false }
+libc = "0.2"
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies.trash]
 version = "2.1.3"
 optional = true
 
 [dependencies.polars]
-version = "0.22.8"
-# path = "../../../../polars/polars"
+version = "0.25.0"
 optional = true
 features = [
-	"default", "to_dummies", "parquet", "json", "serde", "serde-lazy",
-	"object", "checked_arithmetic", "strings", "cum_agg", "is_in",
-	"rolling_window", "strings", "rows", "random",
-  "dtype-datetime", "dtype-struct", "lazy", "cross_join",
-	"dynamic_groupby", "dtype-categorical"
+	"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.37.0"
+version = "0.42.0"
 features = [
-    "alloc",
     "Win32_Foundation",
     "Win32_Storage_FileSystem",
 	"Win32_System_SystemServices",
@@ -123,15 +147,18 @@ features = [
 trash-support = ["trash"]
 which-support = ["which"]
 plugin = ["nu-parser/plugin"]
-dataframe = ["polars", "num"]
-database = ["sqlparser", "rusqlite"]
+dataframe = ["polars", "num", "sqlparser"]
+sqlite = ["rusqlite"] # TODO: given that rusqlite is included in reedline, should we just always include it?
 
 [build-dependencies]
-shadow-rs = { version = "0.11.0", default-features = false }
+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 = "0.12.0"
+rstest = {version = "0.15.0", default-features = false}

crates/nu-command/build.rs

@@ -3,16 +3,18 @@ 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().expect("failed to get latest git commit hash");
+    let hash = get_git_hash().unwrap_or_default();
     println!("cargo:rustc-env=NU_COMMIT_HASH={}", hash);
 
     shadow_rs::new()
 }
 
-fn get_git_hash() -> Result<String, std::io::Error> {
-    let out = Command::new("git").args(["rev-parse", "HEAD"]).output()?;
-    Ok(String::from_utf8(out.stdout)
-        .expect("could not convert stdout to string")
-        .trim()
-        .to_string())
+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

@@ -1,24 +1,14 @@
-use super::{operate, BytesArgument};
+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, Value};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
 
 #[derive(Clone)]
 pub struct BytesLen;
 
-struct Arguments {
-    column_paths: Option<Vec<CellPath>>,
-}
-
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
-    }
-}
-
 impl Command for BytesLen {
     fn name(&self) -> &str {
         "bytes length"
@@ -26,10 +16,12 @@ impl Command for BytesLen {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes length")
+            .input_output_types(vec![(Type::Binary, Type::Int)])
+            .vectorizes_over_list(true)
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "optionally find length of binary by column paths",
+                "for a data structure input, find the length of data at the given cell paths",
             )
             .category(Category::Bytes)
     }
@@ -39,7 +31,7 @@ impl Command for BytesLen {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["len", "size", "count"]
+        vec!["size", "count"]
     }
 
     fn run(
@@ -49,13 +41,8 @@ impl Command for BytesLen {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
-        let arg = Arguments { column_paths };
+        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())
     }
 
@@ -78,10 +65,24 @@ impl Command for BytesLen {
     }
 }
 
-fn length(input: &[u8], _arg: &Arguments, span: Span) -> Value {
-    Value::Int {
-        val: input.len() as i64,
-        span,
+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,
+            ),
+        },
     }
 }
 

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

@@ -1,77 +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;
-use nu_protocol::ast::CellPath;
-use nu_protocol::{PipelineData, ShellError, Span, Value};
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
 
+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;
-
-trait BytesArgument {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>>;
-}
-
-/// map input pipeline data, for each elements, if it's Binary, invoke relative `cmd` with `arg`.
-fn operate<C, A>(
-    cmd: C,
-    mut arg: A,
-    input: PipelineData,
-    span: Span,
-    ctrlc: Option<Arc<AtomicBool>>,
-) -> Result<PipelineData, ShellError>
-where
-    A: BytesArgument + Send + Sync + 'static,
-    C: Fn(&[u8], &A, Span) -> Value + Send + Sync + 'static + Clone + Copy,
-{
-    match arg.take_column_paths() {
-        None => input.map(
-            move |v| match v {
-                Value::Binary {
-                    val,
-                    span: val_span,
-                } => cmd(&val, &arg, val_span),
-                other => Value::Error {
-                    error: ShellError::UnsupportedInput(
-                        format!(
-                            "Input's type is {}. This command only works with bytes.",
-                            other.get_type()
-                        ),
-                        span,
-                    ),
-                },
-            },
-            ctrlc,
-        ),
-        Some(column_paths) => {
-            let arg = Arc::new(arg);
-            input.map(
-                move |mut v| {
-                    for path in &column_paths {
-                        let opt = arg.clone();
-                        let r = v.update_cell_path(
-                            &path.members,
-                            Box::new(move |old| {
-                                match old {
-                                    Value::Binary {val, span: val_span} => cmd(val, &opt, *val_span),
-                                    other => Value::Error {
-                                    error: ShellError::UnsupportedInput(
-                                        format!(
-                                            "Input's type is {}. This command only works with bytes.",
-                                            other.get_type()
-                                        ),
-                                        span,
-                                 ),
-                            }}}),
-                        );
-                        if let Err(error) = r {
-                            return Value::Error { error };
-                        }
-                    }
-                    v
-                },
-                ctrlc,
-            )
-        }
-    }
-}

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

@@ -1,19 +1,19 @@
-use super::{operate, BytesArgument};
+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, Value};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
 
 struct Arguments {
     pattern: Vec<u8>,
-    column_paths: Option<Vec<CellPath>>,
+    cell_paths: Option<Vec<CellPath>>,
 }
 
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
     }
 }
 
@@ -28,11 +28,12 @@ impl Command for BytesStartsWith {
 
     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,
-                "optionally matches prefix of text by column paths",
+                "for a data structure input, check if bytes at the given cell paths start with the pattern",
             )
             .category(Category::Bytes)
     }
@@ -53,15 +54,11 @@ impl Command for BytesStartsWith {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
+        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,
-            column_paths,
+            cell_paths,
         };
         operate(
             starts_with,
@@ -102,10 +99,24 @@ impl Command for BytesStartsWith {
     }
 }
 
-fn starts_with(input: &[u8], Arguments { pattern, .. }: &Arguments, span: Span) -> Value {
-    Value::Bool {
-        val: input.starts_with(pattern),
-        span,
+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,
+            ),
+        },
     }
 }
 

crates/nu-command/src/charting/hashable_value.rs

@@ -13,7 +13,7 @@ use std::hash::{Hash, Hasher};
 /// ```text
 /// assert_eq!(HashableValue::Bool {val: true, span: Span{start: 0, end: 1}}, HashableValue::Bool {val: true, span: Span{start: 90, end: 1000}})
 /// ```
-#[derive(Eq, Debug)]
+#[derive(Eq, Debug, Ord, PartialOrd)]
 pub enum HashableValue {
     Bool {
         val: bool,
@@ -228,7 +228,7 @@ mod test {
                 vals: vec![Value::Bool { val: true, span }],
                 span,
             },
-            Value::Block {
+            Value::Closure {
                 val: 0,
                 captures: HashMap::new(),
                 span,

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

@@ -1,10 +1,11 @@
 use super::hashable_value::HashableValue;
+use itertools::Itertools;
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
     Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape,
-    Value,
+    Type, Value,
 };
 use std::collections::HashMap;
 use std::iter;
@@ -24,6 +25,7 @@ impl Command for Histogram {
 
     fn signature(&self) -> Signature {
         Signature::build("histogram")
+            .input_output_types(vec![(Type::List(Box::new(Type::Any)), Type::Table(vec![])),])
             .optional("column-name", SyntaxShape::String, "column name to calc frequency, no need to provide if input is just a list")
             .optional("frequency-column-name", SyntaxShape::String, "histogram's frequency column, default to be frequency column output")
             .named("percentage-type", SyntaxShape::String, "percentage calculate method, can be 'normalize' or 'relative', in 'normalize', defaults to be 'normalize'", Some('t'))
@@ -36,23 +38,48 @@ impl Command for Histogram {
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
-                description: "Get a histogram for the types of files",
+                description: "Compute a histogram of file types",
                 example: "ls | histogram type",
                 result: None,
             },
             Example {
                 description:
-                    "Get a histogram for the types of files, with frequency column named freq",
+                    "Compute a histogram for the types of files, with frequency column named freq",
                 example: "ls | histogram type freq",
                 result: None,
             },
             Example {
-                description: "Get a histogram for a list of numbers",
-                example: "echo [1 2 3 1 1 1 2 2 1 1] | histogram",
-                result: None,
+                description: "Compute a histogram for a list of numbers",
+                example: "echo [1 2 1] | histogram",
+                result: Some(Value::List {
+                        vals: vec![Value::Record {
+                            cols: vec!["value".to_string(), "count".to_string(), "quantile".to_string(), "percentage".to_string(), "frequency".to_string()],
+                            vals: vec![
+                                Value::test_int(1),
+                                Value::test_int(2),
+                                Value::test_float(0.6666666666666666),
+                                Value::test_string("66.67%"),
+                                Value::test_string("******************************************************************"),
+                            ],
+                            span: Span::test_data(),
+                        },
+                        Value::Record {
+                            cols: vec!["value".to_string(), "count".to_string(), "quantile".to_string(), "percentage".to_string(), "frequency".to_string()],
+                            vals: vec![
+                                Value::test_int(2),
+                                Value::test_int(1),
+                                Value::test_float(0.3333333333333333),
+                                Value::test_string("33.33%"),
+                                Value::test_string("*********************************"),
+                            ],
+                            span: Span::test_data(),
+                        }],
+                        span: Span::test_data(),
+                    }
+                 ),
             },
             Example {
-                description: "Get a histogram for a list of numbers, and percentage is based on the maximum value",
+                description: "Compute a histogram for a list of numbers, and percentage is based on the maximum value",
                 example: "echo [1 2 3 1 1 1 2 2 1 1] | histogram --percentage-type relative",
                 result: None,
             }
@@ -213,10 +240,10 @@ fn histogram_impl(
         freq_column.to_string(),
     ];
     const MAX_FREQ_COUNT: f64 = 100.0;
-    for (val, count) in counter.into_iter() {
+    for (val, count) in counter.into_iter().sorted() {
         let quantile = match calc_method {
-            PercentageCalcMethod::Normalize => (count as f64 / total_cnt as f64),
-            PercentageCalcMethod::Relative => (count as f64 / max_cnt as f64),
+            PercentageCalcMethod::Normalize => count as f64 / total_cnt as f64,
+            PercentageCalcMethod::Relative => count as f64 / max_cnt as f64,
         };
 
         let percentage = format!("{:.2}%", quantile * 100_f64);

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

@@ -1,8 +1,9 @@
+use crate::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, Type, Value,
 };
 
 #[derive(Clone)]
@@ -18,7 +19,9 @@ impl Command for Fmt {
     }
 
     fn signature(&self) -> nu_protocol::Signature {
-        Signature::build("fmt").category(Category::Conversions)
+        Signature::build("fmt")
+            .input_output_types(vec![(Type::Number, Type::Record(vec![]))])
+            .category(Category::Conversions)
     }
 
     fn search_terms(&self) -> Vec<&str> {
@@ -96,31 +99,12 @@ fn fmt(
     call: &Call,
     input: PipelineData,
 ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-    let head = call.head;
-    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-
-    input.map(
-        move |v| {
-            if column_paths.is_empty() {
-                action(&v, head)
-            } else {
-                let mut ret = v;
-                for path in &column_paths {
-                    let r =
-                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
-                    if let Err(error) = r {
-                        return Value::Error { error };
-                    }
-                }
-
-                ret
-            }
-        },
-        engine_state.ctrlc.clone(),
-    )
+    let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+    let args = CellPathOnlyArgs::from(cell_paths);
+    operate(action, args, input, call.head, engine_state.ctrlc.clone())
 }
 
-pub fn action(input: &Value, span: Span) -> Value {
+fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
     match input {
         Value::Int { val, .. } => fmt_it(*val, span),
         Value::Filesize { val, .. } => fmt_it(*val, span),

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

@@ -1,9 +1,10 @@
+use crate::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
     Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
-    Value,
+    Type, Value,
 };
 
 #[derive(Clone)]
@@ -16,10 +17,20 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into binary")
+            .input_output_types(vec![
+                (Type::Binary, Type::Binary),
+                (Type::Int, Type::Binary),
+                (Type::Number, Type::Binary),
+                (Type::String, Type::Binary),
+                (Type::Bool, Type::Binary),
+                (Type::Filesize, Type::Binary),
+                (Type::Date, Type::Binary),
+            ])
+            .allow_variants_without_examples(true) // TODO: supply exhaustive examples
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "column paths to convert to binary (for table input)",
+                "for a data structure input, convert data at the given cell paths",
             )
             .category(Category::Conversions)
     }
@@ -29,7 +40,7 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["convert", "binary", "bytes", "bin"]
+        vec!["convert", "bytes"]
     }
 
     fn run(
@@ -100,7 +111,7 @@ fn into_binary(
     input: PipelineData,
 ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
     let head = call.head;
-    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+    let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
 
     match input {
         PipelineData::ExternalStream { stdout: None, .. } => Ok(Value::Binary {
@@ -120,27 +131,10 @@ fn into_binary(
             }
             .into_pipeline_data())
         }
-        _ => input.map(
-            move |v| {
-                if column_paths.is_empty() {
-                    action(&v, head)
-                } else {
-                    let mut ret = v;
-                    for path in &column_paths {
-                        let r = ret.update_cell_path(
-                            &path.members,
-                            Box::new(move |old| action(old, head)),
-                        );
-                        if let Err(error) = r {
-                            return Value::Error { error };
-                        }
-                    }
-
-                    ret
-                }
-            },
-            engine_state.ctrlc.clone(),
-        ),
+        _ => {
+            let arg = CellPathOnlyArgs::from(cell_paths);
+            operate(action, arg, input, call.head, engine_state.ctrlc.clone())
+        }
     }
 }
 
@@ -160,7 +154,7 @@ fn float_to_endian(n: f64) -> Vec<u8> {
     }
 }
 
-pub fn action(input: &Value, span: Span) -> Value {
+pub fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
     match input {
         Value::Binary { .. } => input.clone(),
         Value::Int { val, .. } => Value::Binary {
@@ -180,7 +174,7 @@ pub fn action(input: &Value, span: Span) -> Value {
             span,
         },
         Value::Bool { val, .. } => Value::Binary {
-            val: int_to_endian(if *val { 1i64 } else { 0 }),
+            val: int_to_endian(i64::from(*val)),
             span,
         },
         Value::Date { val, .. } => Value::Binary {

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

@@ -1,8 +1,9 @@
+use crate::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
 };
 
 #[derive(Clone)]
@@ -15,10 +16,17 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into bool")
+            .input_output_types(vec![
+                (Type::Int, Type::Bool),
+                (Type::Number, Type::Bool),
+                (Type::String, Type::Bool),
+                (Type::Bool, Type::Bool),
+                (Type::List(Box::new(Type::Any)), Type::Table(vec![])),
+            ])
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "column paths to convert to boolean (for table input)",
+                "for a data structure input, convert data at the given cell paths",
             )
             .category(Category::Conversions)
     }
@@ -88,6 +96,11 @@ impl Command for SubCommand {
                 example: "1 | into bool",
                 result: Some(Value::boolean(true, span)),
             },
+            Example {
+                description: "convert decimal to boolean",
+                example: "0.3 | into bool",
+                result: Some(Value::boolean(true, span)),
+            },
             Example {
                 description: "convert decimal string to boolean",
                 example: "'0.0' | into bool",
@@ -108,28 +121,9 @@ fn into_bool(
     call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let head = call.head;
-    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-
-    input.map(
-        move |v| {
-            if column_paths.is_empty() {
-                action(&v, head)
-            } else {
-                let mut ret = v;
-                for path in &column_paths {
-                    let r =
-                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
-                    if let Err(error) = r {
-                        return Value::Error { error };
-                    }
-                }
-
-                ret
-            }
-        },
-        engine_state.ctrlc.clone(),
-    )
+    let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+    let args = CellPathOnlyArgs::from(cell_paths);
+    operate(action, args, input, call.head, engine_state.ctrlc.clone())
 }
 
 fn string_to_boolean(s: &str, span: Span) -> Result<bool, ShellError> {
@@ -154,7 +148,7 @@ fn string_to_boolean(s: &str, span: Span) -> Result<bool, ShellError> {
     }
 }
 
-fn action(input: &Value, span: Span) -> Value {
+fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
     match input {
         Value::Bool { .. } => input.clone(),
         Value::Int { val, .. } => Value::Bool {

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

@@ -29,7 +29,13 @@ impl Command for Into {
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
         Ok(Value::String {
-            val: get_full_help(&Into.signature(), &[], engine_state, stack),
+            val: get_full_help(
+                &Into.signature(),
+                &[],
+                engine_state,
+                stack,
+                self.is_parser_keyword(),
+            ),
             span: call.head,
         }
         .into_pipeline_data())

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

@@ -1,18 +1,25 @@
+use crate::input_handler::{operate, CmdArgument};
 use crate::{generate_strftime_list, parse_date_from_string};
-use chrono::{DateTime, FixedOffset, Local, TimeZone, Utc};
+use chrono::{DateTime, FixedOffset, Local, LocalResult, TimeZone, Utc};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Spanned,
+    SyntaxShape, Type, Value,
 };
 
 struct Arguments {
-    timezone: Option<Spanned<String>>,
-    offset: Option<Spanned<i64>>,
-    format: Option<String>,
-    column_paths: Vec<CellPath>,
+    zone_options: Option<Spanned<Zone>>,
+    format_options: Option<DatetimeFormat>,
+    cell_paths: Option<Vec<CellPath>>,
+}
+
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
+    }
 }
 
 // In case it may be confused with chrono::TimeZone
@@ -57,7 +64,11 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into datetime")
-            .named(
+        .input_output_types(vec![
+            (Type::Int, Type::Date),
+            (Type::String, Type::Date),
+        ])
+        .named(
                 "timezone",
                 SyntaxShape::String,
                 "Specify timezone if the input is a Unix timestamp. Valid options: 'UTC' ('u') or 'LOCAL' ('l')",
@@ -83,7 +94,7 @@ impl Command for SubCommand {
             .rest(
             "rest",
                 SyntaxShape::CellPath,
-                "optionally convert text into datetime by column paths",
+                "for a data structure input, convert data at the given cell paths",
             )
             .category(Category::Conversions)
     }
@@ -95,7 +106,36 @@ impl Command for SubCommand {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        operate(engine_state, stack, call, input)
+        if call.has_flag("list") {
+            Ok(generate_strftime_list(call.head, true).into_pipeline_data())
+        } else {
+            let cell_paths = call.rest(engine_state, stack, 0)?;
+            let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+
+            // if zone-offset is specified, then zone will be neglected
+            let timezone = call.get_flag::<Spanned<String>>(engine_state, stack, "timezone")?;
+            let zone_options =
+                match &call.get_flag::<Spanned<i64>>(engine_state, stack, "offset")? {
+                    Some(zone_offset) => Some(Spanned {
+                        item: Zone::new(zone_offset.item),
+                        span: zone_offset.span,
+                    }),
+                    None => timezone.as_ref().map(|zone| Spanned {
+                        item: Zone::from_string(zone.item.clone()),
+                        span: zone.span,
+                    }),
+                };
+            let format_options = call
+                .get_flag::<String>(engine_state, stack, "format")?
+                .as_ref()
+                .map(|fmt| DatetimeFormat(fmt.to_string()));
+            let args = Arguments {
+                format_options,
+                zone_options,
+                cell_paths,
+            };
+            operate(action, args, input, call.head, engine_state.ctrlc.clone())
+        }
     }
 
     fn usage(&self) -> &str {
@@ -103,42 +143,67 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["convert", "date", "time", "timezone", "UTC"]
+        vec!["convert", "timezone", "UTC"]
     }
 
     fn examples(&self) -> Vec<Example> {
+        let example_result_1 = |secs: i64, nsecs: u32| {
+            let dt = match Utc.timestamp_opt(secs, nsecs) {
+                LocalResult::Single(dt) => Some(dt),
+                _ => None,
+            };
+            match dt {
+                Some(dt) => Some(Value::Date {
+                    val: dt.into(),
+                    span: Span::test_data(),
+                }),
+                None => Some(Value::Error {
+                    error: ShellError::UnsupportedInput(
+                        "The given datetime representation is unsupported.".to_string(),
+                        Span::test_data(),
+                    ),
+                }),
+            }
+        };
+        let example_result_2 = |millis: i64| {
+            let dt = match Utc.timestamp_millis_opt(millis) {
+                LocalResult::Single(dt) => Some(dt),
+                _ => None,
+            };
+            match dt {
+                Some(dt) => Some(Value::Date {
+                    val: dt.into(),
+                    span: Span::test_data(),
+                }),
+                None => Some(Value::Error {
+                    error: ShellError::UnsupportedInput(
+                        "The given datetime representation is unsupported.".to_string(),
+                        Span::test_data(),
+                    ),
+                }),
+            }
+        };
         vec![
             Example {
                 description: "Convert to datetime",
                 example: "'27.02.2021 1:55 pm +0000' | into datetime",
-                result: Some(Value::Date {
-                    val: Utc.timestamp(1614434100, 0).into(),
-                    span: Span::test_data(),
-                }),
+                result: example_result_1(1614434100,0)
             },
             Example {
                 description: "Convert to datetime",
                 example: "'2021-02-27T13:55:40+00:00' | into datetime",
-                result: Some(Value::Date {
-                    val: Utc.timestamp(1614434140, 0).into(),
-                    span: Span::test_data(),
-                }),
+                result: example_result_1(1614434140, 0)
             },
             Example {
                 description: "Convert to datetime using a custom format",
                 example: "'20210227_135540+0000' | into datetime -f '%Y%m%d_%H%M%S%z'",
-                result: Some(Value::Date {
-                    val: Utc.timestamp(1614434140, 0).into(),
-                    span: Span::test_data(),
-                }),
+                result: example_result_1(1614434140, 0)
+
             },
             Example {
                 description: "Convert timestamp (no larger than 8e+12) to a UTC datetime",
                 example: "1614434140 | into datetime",
-                result: Some(Value::Date {
-                    val: Utc.timestamp(1614434140, 0).into(),
-                    span: Span::test_data(),
-                }),
+                result: example_result_1(1614434140, 0)
             },
             Example {
                 description:
@@ -150,10 +215,7 @@ impl Command for SubCommand {
                 description:
                     "Convert timestamps like the sqlite history t",
                 example: "1656165681720 | into datetime",
-                result: Some(Value::Date {
-                    val: Utc.timestamp_millis(1656165681720).into(),
-                    span: Span::test_data(),
-                }),
+                result: example_result_2(1656165681720)
             },
         ]
     }
@@ -162,72 +224,9 @@ impl Command for SubCommand {
 #[derive(Clone)]
 struct DatetimeFormat(String);
 
-fn operate(
-    engine_state: &EngineState,
-    stack: &mut Stack,
-    call: &Call,
-    input: PipelineData,
-) -> Result<PipelineData, ShellError> {
-    let head = call.head;
-
-    let options = Arguments {
-        timezone: call.get_flag(engine_state, stack, "timezone")?,
-        offset: call.get_flag(engine_state, stack, "offset")?,
-        format: call.get_flag(engine_state, stack, "format")?,
-        column_paths: call.rest(engine_state, stack, 0)?,
-    };
-
-    // if zone-offset is specified, then zone will be neglected
-    let zone_options = match &options.offset {
-        Some(zone_offset) => Some(Spanned {
-            item: Zone::new(zone_offset.item),
-            span: zone_offset.span,
-        }),
-        None => options.timezone.as_ref().map(|zone| Spanned {
-            item: Zone::from_string(zone.item.clone()),
-            span: zone.span,
-        }),
-    };
-
-    let list_flag = call.has_flag("list");
-
-    let format_options = options
-        .format
-        .as_ref()
-        .map(|fmt| DatetimeFormat(fmt.to_string()));
-
-    input.map(
-        move |v| {
-            if options.column_paths.is_empty() && !list_flag {
-                action(&v, &zone_options, &format_options, head)
-            } else if list_flag {
-                generate_strftime_list(head, true)
-            } else {
-                let mut ret = v;
-                for path in &options.column_paths {
-                    let zone_options = zone_options.clone();
-                    let format_options = format_options.clone();
-                    let r = ret.update_cell_path(
-                        &path.members,
-                        Box::new(move |old| action(old, &zone_options, &format_options, head)),
-                    );
-                    if let Err(error) = r {
-                        return Value::Error { error };
-                    }
-                }
-                ret
-            }
-        },
-        engine_state.ctrlc.clone(),
-    )
-}
-
-fn action(
-    input: &Value,
-    timezone: &Option<Spanned<Zone>>,
-    dateformat: &Option<DatetimeFormat>,
-    head: Span,
-) -> Value {
+fn action(input: &Value, args: &Arguments, head: Span) -> Value {
+    let timezone = &args.zone_options;
+    let dateformat = &args.format_options;
     // Check to see if input looks like a Unix timestamp (i.e. can it be parsed to an int?)
     let timestamp = match input {
         Value::Int { val, .. } => Ok(*val),
@@ -262,8 +261,31 @@ fn action(
                 // be able to convert chrono::Utc::now()
                 let dt = match ts.to_string().len() {
                     x if x > 13 => Utc.timestamp_nanos(ts).into(),
-                    x if x > 10 => Utc.timestamp_millis(ts).into(),
-                    _ => Utc.timestamp(ts, 0).into(),
+                    x if x > 10 => match Utc.timestamp_millis_opt(ts) {
+                        LocalResult::Single(dt) => dt.into(),
+                        _ => {
+                            return Value::Error {
+                                // This error message is from chrono
+                                error: ShellError::UnsupportedInput(
+                                    "The given local datetime representation is invalid."
+                                        .to_string(),
+                                    head,
+                                ),
+                            };
+                        }
+                    },
+                    _ => match Utc.timestamp_opt(ts, 0) {
+                        LocalResult::Single(dt) => dt.into(),
+                        _ => {
+                            return Value::Error {
+                                error: ShellError::UnsupportedInput(
+                                    "The given local datetime representation is invalid."
+                                        .to_string(),
+                                    head,
+                                ),
+                            }
+                        }
+                    },
                 };
 
                 Value::Date {
@@ -272,28 +294,64 @@ fn action(
                 }
             }
             Some(Spanned { item, span }) => match item {
-                Zone::Utc => Value::Date {
-                    val: Utc.timestamp(ts, 0).into(),
-                    span: head,
-                },
-                Zone::Local => Value::Date {
-                    val: Local.timestamp(ts, 0).into(),
-                    span: head,
-                },
-                Zone::East(i) => {
-                    let eastoffset = FixedOffset::east((*i as i32) * HOUR);
-                    Value::Date {
-                        val: eastoffset.timestamp(ts, 0),
+                Zone::Utc => match Utc.timestamp_opt(ts, 0) {
+                    LocalResult::Single(val) => Value::Date {
+                        val: val.into(),
                         span: head,
-                    }
-                }
-                Zone::West(i) => {
-                    let westoffset = FixedOffset::west((*i as i32) * HOUR);
-                    Value::Date {
-                        val: westoffset.timestamp(ts, 0),
+                    },
+                    _ => Value::Error {
+                        error: ShellError::UnsupportedInput(
+                            "The given local datetime representation is invalid.".to_string(),
+                            *span,
+                        ),
+                    },
+                },
+                Zone::Local => match Local.timestamp_opt(ts, 0) {
+                    LocalResult::Single(val) => Value::Date {
+                        val: val.into(),
                         span: head,
-                    }
-                }
+                    },
+                    _ => Value::Error {
+                        error: ShellError::UnsupportedInput(
+                            "The given local datetime representation is invalid.".to_string(),
+                            *span,
+                        ),
+                    },
+                },
+                Zone::East(i) => match FixedOffset::east_opt((*i as i32) * HOUR) {
+                    Some(eastoffset) => match eastoffset.timestamp_opt(ts, 0) {
+                        LocalResult::Single(val) => Value::Date { val, span: head },
+                        _ => Value::Error {
+                            error: ShellError::UnsupportedInput(
+                                "The given local datetime representation is invalid.".to_string(),
+                                *span,
+                            ),
+                        },
+                    },
+                    None => Value::Error {
+                        error: ShellError::UnsupportedInput(
+                            "The given local datetime representation is invalid.".to_string(),
+                            *span,
+                        ),
+                    },
+                },
+                Zone::West(i) => match FixedOffset::west_opt((*i as i32) * HOUR) {
+                    Some(westoffset) => match westoffset.timestamp_opt(ts, 0) {
+                        LocalResult::Single(val) => Value::Date { val, span: head },
+                        _ => Value::Error {
+                            error: ShellError::UnsupportedInput(
+                                "The given local datetime representation is invalid.".to_string(),
+                                *span,
+                            ),
+                        },
+                    },
+                    None => Value::Error {
+                        error: ShellError::UnsupportedInput(
+                            "The given local datetime representation is invalid.".to_string(),
+                            *span,
+                        ),
+                    },
+                },
                 Zone::Error => Value::Error {
                     error: ShellError::UnsupportedInput(
                         "Cannot convert given timezone or offset to timestamp".to_string(),
@@ -311,7 +369,7 @@ fn action(
                 Some(dt) => match DateTime::parse_from_str(val, &dt.0) {
                     Ok(d) => Value::Date { val: d, span: head },
                     Err(reason) => {
-                        return Value::Error {
+                        Value::Error {
                             error: ShellError::CantConvert(
                                 format!("could not parse as datetime using format '{}'", dt.0),
                                 reason.to_string(),
@@ -359,7 +417,12 @@ mod tests {
     fn takes_a_date_format() {
         let date_str = Value::test_string("16.11.1984 8:00 am +0000");
         let fmt_options = Some(DatetimeFormat("%d.%m.%Y %H:%M %P %z".to_string()));
-        let actual = action(&date_str, &None, &fmt_options, Span::test_data());
+        let args = Arguments {
+            zone_options: None,
+            format_options: fmt_options,
+            cell_paths: None,
+        };
+        let actual = action(&date_str, &args, Span::test_data());
         let expected = Value::Date {
             val: DateTime::parse_from_str("16.11.1984 8:00 am +0000", "%d.%m.%Y %H:%M %P %z")
                 .unwrap(),
@@ -371,7 +434,12 @@ mod tests {
     #[test]
     fn takes_iso8601_date_format() {
         let date_str = Value::test_string("2020-08-04T16:39:18+00:00");
-        let actual = action(&date_str, &None, &None, Span::test_data());
+        let args = Arguments {
+            zone_options: None,
+            format_options: None,
+            cell_paths: None,
+        };
+        let actual = action(&date_str, &args, Span::test_data());
         let expected = Value::Date {
             val: DateTime::parse_from_str("2020-08-04T16:39:18+00:00", "%Y-%m-%dT%H:%M:%S%z")
                 .unwrap(),
@@ -387,7 +455,12 @@ mod tests {
             item: Zone::East(8),
             span: Span::test_data(),
         });
-        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
+        let args = Arguments {
+            zone_options: timezone_option,
+            format_options: None,
+            cell_paths: None,
+        };
+        let actual = action(&date_str, &args, Span::test_data());
         let expected = Value::Date {
             val: DateTime::parse_from_str("2021-02-27 21:55:40 +08:00", "%Y-%m-%d %H:%M:%S %z")
                 .unwrap(),
@@ -404,7 +477,12 @@ mod tests {
             item: Zone::East(8),
             span: Span::test_data(),
         });
-        let actual = action(&date_int, &timezone_option, &None, Span::test_data());
+        let args = Arguments {
+            zone_options: timezone_option,
+            format_options: None,
+            cell_paths: None,
+        };
+        let actual = action(&date_int, &args, Span::test_data());
         let expected = Value::Date {
             val: DateTime::parse_from_str("2021-02-27 21:55:40 +08:00", "%Y-%m-%d %H:%M:%S %z")
                 .unwrap(),
@@ -421,9 +499,14 @@ mod tests {
             item: Zone::Local,
             span: Span::test_data(),
         });
-        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
+        let args = Arguments {
+            zone_options: timezone_option,
+            format_options: None,
+            cell_paths: None,
+        };
+        let actual = action(&date_str, &args, Span::test_data());
         let expected = Value::Date {
-            val: Local.timestamp(1614434140, 0).into(),
+            val: Local.timestamp_opt(1614434140, 0).unwrap().into(),
             span: Span::test_data(),
         };
 
@@ -433,11 +516,15 @@ mod tests {
     #[test]
     fn takes_timestamp_without_timezone() {
         let date_str = Value::test_string("1614434140");
-        let timezone_option = None;
-        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
+        let args = Arguments {
+            zone_options: None,
+            format_options: None,
+            cell_paths: None,
+        };
+        let actual = action(&date_str, &args, Span::test_data());
 
         let expected = Value::Date {
-            val: Utc.timestamp(1614434140, 0).into(),
+            val: Utc.timestamp_opt(1614434140, 0).unwrap().into(),
             span: Span::test_data(),
         };
 
@@ -451,7 +538,12 @@ mod tests {
             item: Zone::Utc,
             span: Span::test_data(),
         });
-        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
+        let args = Arguments {
+            zone_options: timezone_option,
+            format_options: None,
+            cell_paths: None,
+        };
+        let actual = action(&date_str, &args, Span::test_data());
 
         assert_eq!(actual.get_type(), Error);
     }
@@ -460,7 +552,12 @@ mod tests {
     fn communicates_parsing_error_given_an_invalid_datetimelike_string() {
         let date_str = Value::test_string("16.11.1984 8:00 am Oops0000");
         let fmt_options = Some(DatetimeFormat("%d.%m.%Y %H:%M %P %z".to_string()));
-        let actual = action(&date_str, &None, &fmt_options, Span::test_data());
+        let args = Arguments {
+            zone_options: None,
+            format_options: fmt_options,
+            cell_paths: None,
+        };
+        let actual = action(&date_str, &args, Span::test_data());
 
         assert_eq!(actual.get_type(), Error);
     }

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

@@ -1,8 +1,9 @@
+use crate::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
+    Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
 };
 
 #[derive(Clone)]
@@ -14,11 +15,16 @@ impl Command for SubCommand {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("into decimal").rest(
-            "rest",
-            SyntaxShape::CellPath,
-            "optionally convert text into decimal by column paths",
-        )
+        Signature::build("into decimal")
+            .input_output_types(vec![
+                (Type::String, Type::Number),
+                (Type::Bool, Type::Number),
+            ])
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "for a data structure input, convert data at the given cell paths",
+            )
     }
 
     fn usage(&self) -> &str {
@@ -36,13 +42,15 @@ impl Command for SubCommand {
         call: &Call,
         input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        operate(engine_state, stack, call, input)
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+        let args = CellPathOnlyArgs::from(cell_paths);
+        operate(action, args, input, call.head, engine_state.ctrlc.clone())
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
-                description: "Convert string to integer in table",
+                description: "Convert string to decimal in table",
                 example: "[[num]; ['5.01']] | into decimal num",
                 result: Some(Value::List {
                     vals: vec![Value::Record {
@@ -54,50 +62,25 @@ impl Command for SubCommand {
                 }),
             },
             Example {
-                description: "Convert string to integer",
+                description: "Convert string to decimal",
                 example: "'1.345' | into decimal",
                 result: Some(Value::test_float(1.345)),
             },
             Example {
-                description: "Convert decimal to integer",
+                description: "Convert decimal to decimal",
                 example: "'-5.9' | into decimal",
                 result: Some(Value::test_float(-5.9)),
             },
+            Example {
+                description: "Convert boolean to decimal",
+                example: "true | into decimal",
+                result: Some(Value::test_float(1.0)),
+            },
         ]
     }
 }
 
-fn operate(
-    engine_state: &EngineState,
-    stack: &mut Stack,
-    call: &Call,
-    input: PipelineData,
-) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-    let head = call.head;
-    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-
-    input.map(
-        move |v| {
-            if column_paths.is_empty() {
-                action(&v, head)
-            } else {
-                let mut ret = v;
-                for path in &column_paths {
-                    let r =
-                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
-                    if let Err(error) = r {
-                        return Value::Error { error };
-                    }
-                }
-
-                ret
-            }
-        },
-        engine_state.ctrlc.clone(),
-    )
-}
-
-fn action(input: &Value, head: Span) -> Value {
+fn action(input: &Value, _args: &CellPathOnlyArgs, head: Span) -> Value {
     match input {
         Value::String { val: s, span } => {
             let other = s.trim();
@@ -118,6 +101,13 @@ fn action(input: &Value, head: Span) -> Value {
             val: *v as f64,
             span: *span,
         },
+        Value::Bool { val: b, span } => Value::Float {
+            val: match b {
+                true => 1.0,
+                false => 0.0,
+            },
+            span: *span,
+        },
         other => {
             let span = other.span();
             match span {
@@ -151,7 +141,7 @@ mod tests {
         let word = Value::test_string("3.1415");
         let expected = Value::test_float(3.1415);
 
-        let actual = action(&word, Span::test_data());
+        let actual = action(&word, &CellPathOnlyArgs::from(vec![]), Span::test_data());
         assert_eq!(actual, expected);
     }
 
@@ -159,7 +149,11 @@ mod tests {
     fn communicates_parsing_error_given_an_invalid_decimallike_string() {
         let decimal_str = Value::test_string("11.6anra");
 
-        let actual = action(&decimal_str, Span::test_data());
+        let actual = action(
+            &decimal_str,
+            &CellPathOnlyArgs::from(vec![]),
+            Span::test_data(),
+        );
 
         assert_eq!(actual.get_type(), Error);
     }
@@ -168,7 +162,11 @@ mod tests {
     fn int_to_decimal() {
         let decimal_str = Value::test_int(10);
         let expected = Value::test_float(10.0);
-        let actual = action(&decimal_str, Span::test_data());
+        let actual = action(
+            &decimal_str,
+            &CellPathOnlyArgs::from(vec![]),
+            Span::test_data(),
+        );
 
         assert_eq!(actual, expected);
     }

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

@@ -3,7 +3,8 @@ use nu_parser::parse_duration_bytes;
 use nu_protocol::{
     ast::{Call, CellPath, Expr},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Unit, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Unit,
+    Value,
 };
 
 #[derive(Clone)]
@@ -16,10 +17,23 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into duration")
+            .input_output_types(vec![
+                (Type::String, Type::Duration),
+                (Type::Duration, Type::Duration),
+                // TODO: --convert option should be implemented as `format duration`
+                (Type::String, Type::String),
+                (Type::Duration, Type::String),
+            ])
+            .named(
+                "convert",
+                SyntaxShape::String,
+                "convert duration into another duration",
+                Some('c'),
+            )
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "column paths to convert to duration (for table input)",
+                "for a data structure input, convert data at the given cell paths",
             )
             .category(Category::Conversions)
     }
@@ -28,6 +42,10 @@ impl Command for SubCommand {
         "Convert value to duration"
     }
 
+    fn extra_usage(&self) -> &str {
+        "This command does not take leap years into account, and every month is assumed to have 30 days."
+    }
+
     fn search_terms(&self) -> Vec<&str> {
         vec!["convert", "time", "period"]
     }
@@ -102,6 +120,30 @@ impl Command for SubCommand {
                     span,
                 }),
             },
+            Example {
+                description: "Convert string to the requested duration as a string",
+                example: "'7min' | into duration --convert sec",
+                result: Some(Value::String {
+                    val: "420 sec".to_string(),
+                    span,
+                }),
+            },
+            Example {
+                description: "Convert duration to duration",
+                example: "420sec | into duration",
+                result: Some(Value::Duration {
+                    val: 7 * 60 * 1000 * 1000 * 1000,
+                    span,
+                }),
+            },
+            Example {
+                description: "Convert duration to the requested duration as a string",
+                example: "420sec | into duration --convert ms",
+                result: Some(Value::String {
+                    val: "420000 ms".to_string(),
+                    span,
+                }),
+            },
         ]
     }
 }
@@ -113,17 +155,23 @@ fn into_duration(
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
     let head = call.head;
+    let convert_to_unit: Option<Spanned<String>> = call.get_flag(engine_state, stack, "convert")?;
     let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+    let config = engine_state.get_config();
+    let float_precision = config.float_precision as usize;
 
     input.map(
         move |v| {
             if column_paths.is_empty() {
-                action(&v, head)
+                action(&v, &convert_to_unit, float_precision, head)
             } else {
                 let mut ret = v;
                 for path in &column_paths {
-                    let r =
-                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
+                    let d = convert_to_unit.clone();
+                    let r = ret.update_cell_path(
+                        &path.members,
+                        Box::new(move |old| action(old, &d, float_precision, head)),
+                    );
                     if let Err(error) = r {
                         return Value::Error { error };
                     }
@@ -136,7 +184,151 @@ fn into_duration(
     )
 }
 
-fn string_to_duration(s: &str, span: Span) -> Result<i64, ShellError> {
+fn convert_str_from_unit_to_unit(
+    val: i64,
+    from_unit: &str,
+    to_unit: &str,
+    span: Span,
+    value_span: Span,
+) -> Result<f64, ShellError> {
+    match (from_unit, to_unit) {
+        ("ns", "ns") => Ok(val as f64),
+        ("ns", "us") => Ok(val as f64 / 1000.0),
+        ("ns", "ms") => Ok(val as f64 / 1000.0 / 1000.0),
+        ("ns", "sec") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0),
+        ("ns", "min") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0),
+        ("ns", "hr") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0),
+        ("ns", "day") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0),
+        ("ns", "wk") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 7.0),
+        ("ns", "month") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 30.0),
+        ("ns", "yr") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0),
+        ("ns", "dec") => {
+            Ok(val as f64 / 10.0 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0)
+        }
+
+        ("us", "ns") => Ok(val as f64 * 1000.0),
+        ("us", "us") => Ok(val as f64),
+        ("us", "ms") => Ok(val as f64 / 1000.0),
+        ("us", "sec") => Ok(val as f64 / 1000.0 / 1000.0),
+        ("us", "min") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0),
+        ("us", "hr") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0 / 60.0),
+        ("us", "day") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0),
+        ("us", "wk") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 7.0),
+        ("us", "month") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 30.0),
+        ("us", "yr") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0),
+        ("us", "dec") => Ok(val as f64 / 10.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0),
+
+        ("ms", "ns") => Ok(val as f64 * 1000.0 * 1000.0),
+        ("ms", "us") => Ok(val as f64 * 1000.0),
+        ("ms", "ms") => Ok(val as f64),
+        ("ms", "sec") => Ok(val as f64 / 1000.0),
+        ("ms", "min") => Ok(val as f64 / 1000.0 / 60.0),
+        ("ms", "hr") => Ok(val as f64 / 1000.0 / 60.0 / 60.0),
+        ("ms", "day") => Ok(val as f64 / 1000.0 / 60.0 / 60.0 / 24.0),
+        ("ms", "wk") => Ok(val as f64 / 1000.0 / 60.0 / 60.0 / 24.0 / 7.0),
+        ("ms", "month") => Ok(val as f64 / 1000.0 / 60.0 / 60.0 / 24.0 / 30.0),
+        ("ms", "yr") => Ok(val as f64 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0),
+        ("ms", "dec") => Ok(val as f64 / 10.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0),
+
+        ("sec", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0),
+        ("sec", "us") => Ok(val as f64 * 1000.0 * 1000.0),
+        ("sec", "ms") => Ok(val as f64 * 1000.0),
+        ("sec", "sec") => Ok(val as f64),
+        ("sec", "min") => Ok(val as f64 / 60.0),
+        ("sec", "hr") => Ok(val as f64 / 60.0 / 60.0),
+        ("sec", "day") => Ok(val as f64 / 60.0 / 60.0 / 24.0),
+        ("sec", "wk") => Ok(val as f64 / 60.0 / 60.0 / 24.0 / 7.0),
+        ("sec", "month") => Ok(val as f64 / 60.0 / 60.0 / 24.0 / 30.0),
+        ("sec", "yr") => Ok(val as f64 / 60.0 / 60.0 / 24.0 / 365.0),
+        ("sec", "dec") => Ok(val as f64 / 10.0 / 60.0 / 60.0 / 24.0 / 365.0),
+
+        ("min", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0),
+        ("min", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0),
+        ("min", "ms") => Ok(val as f64 * 1000.0 * 60.0),
+        ("min", "sec") => Ok(val as f64 * 60.0),
+        ("min", "min") => Ok(val as f64),
+        ("min", "hr") => Ok(val as f64 / 60.0),
+        ("min", "day") => Ok(val as f64 / 60.0 / 24.0),
+        ("min", "wk") => Ok(val as f64 / 60.0 / 24.0 / 7.0),
+        ("min", "month") => Ok(val as f64 / 60.0 / 24.0 / 30.0),
+        ("min", "yr") => Ok(val as f64 / 60.0 / 24.0 / 365.0),
+        ("min", "dec") => Ok(val as f64 / 10.0 / 60.0 / 24.0 / 365.0),
+
+        ("hr", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0 * 60.0),
+        ("hr", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0 * 60.0),
+        ("hr", "ms") => Ok(val as f64 * 1000.0 * 60.0 * 60.0),
+        ("hr", "sec") => Ok(val as f64 * 60.0 * 60.0),
+        ("hr", "min") => Ok(val as f64 * 60.0),
+        ("hr", "hr") => Ok(val as f64),
+        ("hr", "day") => Ok(val as f64 / 24.0),
+        ("hr", "wk") => Ok(val as f64 / 24.0 / 7.0),
+        ("hr", "month") => Ok(val as f64 / 24.0 / 30.0),
+        ("hr", "yr") => Ok(val as f64 / 24.0 / 365.0),
+        ("hr", "dec") => Ok(val as f64 / 10.0 / 24.0 / 365.0),
+
+        ("day", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0),
+        ("day", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0),
+        ("day", "ms") => Ok(val as f64 * 1000.0 * 60.0 * 60.0 * 24.0),
+        ("day", "sec") => Ok(val as f64 * 60.0 * 60.0 * 24.0),
+        ("day", "min") => Ok(val as f64 * 60.0 * 24.0),
+        ("day", "hr") => Ok(val as f64 * 24.0),
+        ("day", "day") => Ok(val as f64),
+        ("day", "wk") => Ok(val as f64 / 7.0),
+        ("day", "month") => Ok(val as f64 / 30.0),
+        ("day", "yr") => Ok(val as f64 / 365.0),
+        ("day", "dec") => Ok(val as f64 / 10.0 / 365.0),
+
+        ("wk", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 7.0),
+        ("wk", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 7.0),
+        ("wk", "ms") => Ok(val as f64 * 1000.0 * 60.0 * 60.0 * 24.0 * 7.0),
+        ("wk", "sec") => Ok(val as f64 * 60.0 * 60.0 * 24.0 * 7.0),
+        ("wk", "min") => Ok(val as f64 * 60.0 * 24.0 * 7.0),
+        ("wk", "hr") => Ok(val as f64 * 24.0 * 7.0),
+        ("wk", "day") => Ok(val as f64 * 7.0),
+        ("wk", "wk") => Ok(val as f64),
+        ("wk", "month") => Ok(val as f64 / 4.0),
+        ("wk", "yr") => Ok(val as f64 / 52.0),
+        ("wk", "dec") => Ok(val as f64 / 10.0 / 52.0),
+
+        ("month", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 30.0),
+        ("month", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 30.0),
+        ("month", "ms") => Ok(val as f64 * 1000.0 * 60.0 * 60.0 * 24.0 * 30.0),
+        ("month", "sec") => Ok(val as f64 * 60.0 * 60.0 * 24.0 * 30.0),
+        ("month", "min") => Ok(val as f64 * 60.0 * 24.0 * 30.0),
+        ("month", "hr") => Ok(val as f64 * 24.0 * 30.0),
+        ("month", "day") => Ok(val as f64 * 30.0),
+        ("month", "wk") => Ok(val as f64 * 4.0),
+        ("month", "month") => Ok(val as f64),
+        ("month", "yr") => Ok(val as f64 / 12.0),
+        ("month", "dec") => Ok(val as f64 / 10.0 / 12.0),
+
+        ("yr", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 365.0),
+        ("yr", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 365.0),
+        ("yr", "ms") => Ok(val as f64 * 1000.0 * 60.0 * 60.0 * 24.0 * 365.0),
+        ("yr", "sec") => Ok(val as f64 * 60.0 * 60.0 * 24.0 * 365.0),
+        ("yr", "min") => Ok(val as f64 * 60.0 * 24.0 * 365.0),
+        ("yr", "hr") => Ok(val as f64 * 24.0 * 365.0),
+        ("yr", "day") => Ok(val as f64 * 365.0),
+        ("yr", "wk") => Ok(val as f64 * 52.0),
+        ("yr", "month") => Ok(val as f64 * 12.0),
+        ("yr", "yr") => Ok(val as f64),
+        ("yr", "dec") => Ok(val as f64 / 10.0),
+
+        _ => Err(ShellError::CantConvertWithValue(
+            "string duration".to_string(),
+            "string duration".to_string(),
+            to_unit.to_string(),
+            span,
+            value_span,
+            Some(
+                "supported units are ns, us, ms, sec, min, hr, day, wk, month, yr and dec"
+                    .to_string(),
+            ),
+        )),
+    }
+}
+
+fn string_to_duration(s: &str, span: Span, value_span: Span) -> Result<i64, ShellError> {
     if let Some(expression) = parse_duration_bytes(s.as_bytes(), span) {
         if let Expr::ValueWithUnit(value, unit) = expression.expr {
             if let Expr::Int(x) = value.expr {
@@ -155,21 +347,139 @@ fn string_to_duration(s: &str, span: Span) -> Result<i64, ShellError> {
         }
     }
 
-    Err(ShellError::CantConvert(
+    Err(ShellError::CantConvertWithValue(
         "duration".to_string(),
         "string".to_string(),
+        s.to_string(),
         span,
-        Some("supported units are ns, us, ms, sec, min, hr, day, and wk".to_string()),
+        value_span,
+        Some(
+            "supported units are ns, us, ms, sec, min, hr, day, wk, month, yr and dec".to_string(),
+        ),
     ))
 }
 
-fn action(input: &Value, span: Span) -> Value {
+fn string_to_unit_duration(
+    s: &str,
+    span: Span,
+    value_span: Span,
+) -> Result<(&str, i64), ShellError> {
+    if let Some(expression) = parse_duration_bytes(s.as_bytes(), span) {
+        if let Expr::ValueWithUnit(value, unit) = expression.expr {
+            if let Expr::Int(x) = value.expr {
+                match unit.item {
+                    Unit::Nanosecond => return Ok(("ns", x)),
+                    Unit::Microsecond => return Ok(("us", x)),
+                    Unit::Millisecond => return Ok(("ms", x)),
+                    Unit::Second => return Ok(("sec", x)),
+                    Unit::Minute => return Ok(("min", x)),
+                    Unit::Hour => return Ok(("hr", x)),
+                    Unit::Day => return Ok(("day", x)),
+                    Unit::Week => return Ok(("wk", x)),
+
+                    _ => return Ok(("ns", 0)),
+                }
+            }
+        }
+    }
+
+    Err(ShellError::CantConvertWithValue(
+        "duration".to_string(),
+        "string".to_string(),
+        s.to_string(),
+        span,
+        value_span,
+        Some(
+            "supported units are ns, us, ms, sec, min, hr, day, wk, month, yr and dec".to_string(),
+        ),
+    ))
+}
+
+fn action(
+    input: &Value,
+    convert_to_unit: &Option<Spanned<String>>,
+    float_precision: usize,
+    span: Span,
+) -> Value {
     match input {
-        Value::Duration { .. } => input.clone(),
-        Value::String { val, .. } => match string_to_duration(val, span) {
-            Ok(val) => Value::Duration { val, span },
-            Err(error) => Value::Error { error },
-        },
+        Value::Duration {
+            val: val_num,
+            span: value_span,
+        } => {
+            if let Some(to_unit) = convert_to_unit {
+                let from_unit = "ns";
+                let duration = *val_num;
+                match convert_str_from_unit_to_unit(
+                    duration,
+                    from_unit,
+                    &to_unit.item,
+                    span,
+                    *value_span,
+                ) {
+                    Ok(d) => {
+                        if d.fract() == 0.0 {
+                            Value::String {
+                                val: format!("{} {}", d, &to_unit.item),
+                                span: *value_span,
+                            }
+                        } else {
+                            Value::String {
+                                val: format!("{:.float_precision$} {}", d, &to_unit.item),
+                                span: *value_span,
+                            }
+                        }
+                    }
+                    Err(e) => Value::Error { error: e },
+                }
+            } else {
+                input.clone()
+            }
+        }
+        Value::String {
+            val,
+            span: value_span,
+        } => {
+            if let Some(to_unit) = convert_to_unit {
+                if let Ok(dur) = string_to_unit_duration(val, span, *value_span) {
+                    let from_unit = dur.0;
+                    let duration = dur.1;
+                    match convert_str_from_unit_to_unit(
+                        duration,
+                        from_unit,
+                        &to_unit.item,
+                        span,
+                        *value_span,
+                    ) {
+                        Ok(d) => {
+                            if d.fract() == 0.0 {
+                                Value::String {
+                                    val: format!("{} {}", d, &to_unit.item),
+                                    span: *value_span,
+                                }
+                            } else {
+                                Value::String {
+                                    val: format!("{:.float_precision$} {}", d, &to_unit.item),
+                                    span: *value_span,
+                                }
+                            }
+                        }
+                        Err(e) => Value::Error { error: e },
+                    }
+                } else {
+                    Value::Error {
+                        error: ShellError::UnsupportedInput(
+                            "'into duration' does not support this string input".into(),
+                            span,
+                        ),
+                    }
+                }
+            } else {
+                match string_to_duration(val, span, *value_span) {
+                    Ok(val) => Value::Duration { val, span },
+                    Err(error) => Value::Error { error },
+                }
+            }
+        }
         _ => Value::Error {
             error: ShellError::UnsupportedInput(
                 "'into duration' does not support this input".into(),
@@ -195,8 +505,9 @@ mod test {
         let span = Span::test_data();
         let word = Value::test_string("3ns");
         let expected = Value::Duration { val: 3, span };
+        let convert_duration = None;
 
-        let actual = action(&word, span);
+        let actual = action(&word, &convert_duration, 2, span);
         assert_eq!(actual, expected);
     }
 
@@ -208,8 +519,9 @@ mod test {
             val: 4 * 1000,
             span,
         };
+        let convert_duration = None;
 
-        let actual = action(&word, span);
+        let actual = action(&word, &convert_duration, 2, span);
         assert_eq!(actual, expected);
     }
 
@@ -221,8 +533,9 @@ mod test {
             val: 5 * 1000 * 1000,
             span,
         };
+        let convert_duration = None;
 
-        let actual = action(&word, span);
+        let actual = action(&word, &convert_duration, 2, span);
         assert_eq!(actual, expected);
     }
 
@@ -234,8 +547,9 @@ mod test {
             val: 1000 * 1000 * 1000,
             span,
         };
+        let convert_duration = None;
 
-        let actual = action(&word, span);
+        let actual = action(&word, &convert_duration, 2, span);
         assert_eq!(actual, expected);
     }
 
@@ -247,8 +561,9 @@ mod test {
             val: 7 * 60 * 1000 * 1000 * 1000,
             span,
         };
+        let convert_duration = None;
 
-        let actual = action(&word, span);
+        let actual = action(&word, &convert_duration, 2, span);
         assert_eq!(actual, expected);
     }
 
@@ -260,8 +575,9 @@ mod test {
             val: 42 * 60 * 60 * 1000 * 1000 * 1000,
             span,
         };
+        let convert_duration = None;
 
-        let actual = action(&word, span);
+        let actual = action(&word, &convert_duration, 2, span);
         assert_eq!(actual, expected);
     }
 
@@ -273,8 +589,9 @@ mod test {
             val: 123 * 24 * 60 * 60 * 1000 * 1000 * 1000,
             span,
         };
+        let convert_duration = None;
 
-        let actual = action(&word, span);
+        let actual = action(&word, &convert_duration, 2, span);
         assert_eq!(actual, expected);
     }
 
@@ -286,8 +603,9 @@ mod test {
             val: 3 * 7 * 24 * 60 * 60 * 1000 * 1000 * 1000,
             span,
         };
+        let convert_duration = None;
 
-        let actual = action(&word, span);
+        let actual = action(&word, &convert_duration, 2, span);
         assert_eq!(actual, expected);
     }
 }

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

@@ -1,8 +1,9 @@
+use crate::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
 };
 
 #[derive(Clone)]
@@ -15,10 +16,16 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into filesize")
+            .input_output_types(vec![
+                (Type::Int, Type::Filesize),
+                (Type::Number, Type::Filesize),
+                (Type::String, Type::Filesize),
+                (Type::Filesize, Type::Filesize),
+            ])
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "column paths to convert to filesize (for table input)",
+                "for a data structure input, convert data at the given cell paths",
             )
             .category(Category::Conversions)
     }
@@ -28,7 +35,7 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["convert", "number", "size", "bytes"]
+        vec!["convert", "number", "bytes"]
     }
 
     fn run(
@@ -38,7 +45,9 @@ impl Command for SubCommand {
         call: &Call,
         input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        into_filesize(engine_state, stack, call, input)
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+        let args = CellPathOnlyArgs::from(cell_paths);
+        operate(action, args, input, call.head, engine_state.ctrlc.clone())
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -84,37 +93,7 @@ impl Command for SubCommand {
     }
 }
 
-fn into_filesize(
-    engine_state: &EngineState,
-    stack: &mut Stack,
-    call: &Call,
-    input: PipelineData,
-) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-    let head = call.head;
-    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-
-    input.map(
-        move |v| {
-            if column_paths.is_empty() {
-                action(&v, head)
-            } else {
-                let mut ret = v;
-                for path in &column_paths {
-                    let r =
-                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
-                    if let Err(error) = r {
-                        return Value::Error { error };
-                    }
-                }
-
-                ret
-            }
-        },
-        engine_state.ctrlc.clone(),
-    )
-}
-
-pub fn action(input: &Value, span: Span) -> Value {
+pub fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
     if let Ok(value_span) = input.span() {
         match input {
             Value::Filesize { .. } => input.clone(),

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

@@ -1,16 +1,23 @@
+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, SyntaxShape, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
 };
 
 struct Arguments {
-    radix: Option<Value>,
-    column_paths: Vec<CellPath>,
+    radix: u32,
+    cell_paths: Option<Vec<CellPath>>,
     little_endian: bool,
 }
 
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
+    }
+}
+
 #[derive(Clone)]
 pub struct SubCommand;
 
@@ -21,12 +28,22 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into int")
+            .input_output_types(vec![
+                (Type::String, Type::Int),
+                (Type::Number, Type::Int),
+                (Type::Bool, Type::Int),
+                // Unix timestamp in seconds
+                (Type::Date, Type::Int),
+                // TODO: Users should do this by dividing a Filesize by a Filesize explicitly
+                (Type::Filesize, Type::Int),
+            ])
+            .vectorizes_over_list(true)
             .named("radix", SyntaxShape::Number, "radix of integer", Some('r'))
             .switch("little-endian", "use little-endian byte decoding", None)
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "column paths to convert to int (for table input)",
+                "for a data structure input, convert data at the given cell paths",
             )
             .category(Category::Conversions)
     }
@@ -46,7 +63,29 @@ impl Command for SubCommand {
         call: &Call,
         input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        into_int(engine_state, stack, call, input)
+        let cell_paths = call.rest(engine_state, stack, 0)?;
+        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+
+        let radix = call.get_flag::<Value>(engine_state, stack, "radix")?;
+        let radix: u32 = match radix {
+            Some(Value::Int { val, span }) => {
+                if !(2..=36).contains(&val) {
+                    return Err(ShellError::UnsupportedInput(
+                        "Radix must lie in the range [2, 36]".to_string(),
+                        span,
+                    ));
+                }
+                val as u32
+            }
+            Some(_) => 10,
+            None => 10,
+        };
+        let args = Arguments {
+            radix,
+            little_endian: call.has_flag("little-endian"),
+            cell_paths,
+        };
+        operate(action, args, input, call.head, engine_state.ctrlc.clone())
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -102,63 +141,28 @@ impl Command for SubCommand {
                 example: "'FF' |  into int -r 16",
                 result: Some(Value::test_int(255)),
             },
+            Example {
+                description: "Convert octal string to integer",
+                example: "'0o10132' | into int",
+                result: Some(Value::test_int(4186)),
+            },
+            Example {
+                description: "Convert 0 padded string to integer",
+                example: "'0010132' | into int",
+                result: Some(Value::test_int(10132)),
+            },
+            Example {
+                description: "Convert 0 padded string to integer with radix",
+                example: "'0010132' | into int -r 8",
+                result: Some(Value::test_int(4186)),
+            },
         ]
     }
 }
 
-fn into_int(
-    engine_state: &EngineState,
-    stack: &mut Stack,
-    call: &Call,
-    input: PipelineData,
-) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-    let head = call.head;
-
-    let options = Arguments {
-        radix: call.get_flag(engine_state, stack, "radix")?,
-        little_endian: call.has_flag("little-endian"),
-        column_paths: call.rest(engine_state, stack, 0)?,
-    };
-
-    let radix: u32 = match options.radix {
-        Some(Value::Int { val, .. }) => val as u32,
-        Some(_) => 10,
-        None => 10,
-    };
-
-    if let Some(val) = &options.radix {
-        if !(2..=36).contains(&radix) {
-            return Err(ShellError::UnsupportedInput(
-                "Radix must lie in the range [2, 36]".to_string(),
-                val.span()?,
-            ));
-        }
-    }
-
-    input.map(
-        move |v| {
-            if options.column_paths.is_empty() {
-                action(&v, head, radix, options.little_endian)
-            } else {
-                let mut ret = v;
-                for path in &options.column_paths {
-                    let r = ret.update_cell_path(
-                        &path.members,
-                        Box::new(move |old| action(old, head, radix, options.little_endian)),
-                    );
-                    if let Err(error) = r {
-                        return Value::Error { error };
-                    }
-                }
-
-                ret
-            }
-        },
-        engine_state.ctrlc.clone(),
-    )
-}
-
-pub fn action(input: &Value, span: Span, radix: u32, little_endian: bool) -> Value {
+fn action(input: &Value, args: &Arguments, span: Span) -> Value {
+    let radix = args.radix;
+    let little_endian = args.little_endian;
     match input {
         Value::Int { val: _, .. } => {
             if radix == 10 {
@@ -169,7 +173,32 @@ pub fn action(input: &Value, span: Span, radix: u32, little_endian: bool) -> Val
         }
         Value::Filesize { val, .. } => Value::Int { val: *val, span },
         Value::Float { val, .. } => Value::Int {
-            val: *val as i64,
+            val: {
+                if radix == 10 {
+                    *val as i64
+                } else {
+                    match convert_int(
+                        &Value::Int {
+                            val: *val as i64,
+                            span,
+                        },
+                        span,
+                        radix,
+                    )
+                    .as_i64()
+                    {
+                        Ok(v) => v,
+                        _ => {
+                            return Value::Error {
+                                error: ShellError::UnsupportedInput(
+                                    "Could not convert float to integer".to_string(),
+                                    span,
+                                ),
+                            }
+                        }
+                    }
+                }
+            },
             span,
         },
         Value::String { val, .. } => {
@@ -233,11 +262,31 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
     let i = match input {
         Value::Int { val, .. } => val.to_string(),
         Value::String { val, .. } => {
-            if val.starts_with("0x") || val.starts_with("0b") {
+            let val = val.trim();
+            if val.starts_with("0x") // hex
+                || val.starts_with("0b") // binary
+                || val.starts_with("0o")
+            // octal
+            {
                 match int_from_string(val, head) {
                     Ok(x) => return Value::Int { val: x, span: head },
                     Err(e) => return Value::Error { error: e },
                 }
+            } else if val.starts_with("00") {
+                // It's a padded string
+                match i64::from_str_radix(val, radix) {
+                    Ok(n) => return Value::Int { val: n, span: head },
+                    Err(e) => {
+                        return Value::Error {
+                            error: ShellError::CantConvert(
+                                "string".to_string(),
+                                "int".to_string(),
+                                head,
+                                Some(e.to_string()),
+                            ),
+                        }
+                    }
+                }
             }
             val.to_string()
         }
@@ -250,10 +299,10 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
             }
         }
     };
-    match i64::from_str_radix(&i, radix) {
+    match i64::from_str_radix(i.trim(), radix) {
         Ok(n) => Value::Int { val: n, span: head },
         Err(_reason) => Value::Error {
-            error: ShellError::CantConvert("int".to_string(), "string".to_string(), head, None),
+            error: ShellError::CantConvert("string".to_string(), "int".to_string(), head, None),
         },
     }
 }
@@ -291,7 +340,21 @@ fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {
                 };
             Ok(num)
         }
-        _ => match a_string.parse::<i64>() {
+        o if o.starts_with("0o") => {
+            let num = match i64::from_str_radix(o.trim_start_matches("0o"), 8) {
+                Ok(n) => n,
+                Err(_reason) => {
+                    return Err(ShellError::CantConvert(
+                        "int".to_string(),
+                        "string".to_string(),
+                        span,
+                        Some(r#"octal digits following "0o" should be in 0-7"#.to_string()),
+                    ))
+                }
+            };
+            Ok(num)
+        }
+        _ => match trimmed.parse::<i64>() {
             Ok(n) => Ok(n),
             Err(_) => match a_string.parse::<f64>() {
                 Ok(f) => Ok(f as i64),
@@ -299,7 +362,10 @@ fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {
                     "int".to_string(),
                     "string".to_string(),
                     span,
-                    None,
+                    Some(format!(
+                        r#"string "{}" does not represent a valid integer"#,
+                        trimmed
+                    )),
                 )),
             },
         },
@@ -324,21 +390,45 @@ mod test {
         let word = Value::test_string("10");
         let expected = Value::test_int(10);
 
-        let actual = action(&word, Span::test_data(), 10, false);
+        let actual = action(
+            &word,
+            &Arguments {
+                radix: 10,
+                cell_paths: None,
+                little_endian: false,
+            },
+            Span::test_data(),
+        );
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn turns_binary_to_integer() {
         let s = Value::test_string("0b101");
-        let actual = action(&s, Span::test_data(), 10, false);
+        let actual = action(
+            &s,
+            &Arguments {
+                radix: 10,
+                cell_paths: None,
+                little_endian: false,
+            },
+            Span::test_data(),
+        );
         assert_eq!(actual, Value::test_int(5));
     }
 
     #[test]
     fn turns_hex_to_integer() {
         let s = Value::test_string("0xFF");
-        let actual = action(&s, Span::test_data(), 16, false);
+        let actual = action(
+            &s,
+            &Arguments {
+                radix: 16,
+                cell_paths: None,
+                little_endian: false,
+            },
+            Span::test_data(),
+        );
         assert_eq!(actual, Value::test_int(255));
     }
 
@@ -346,7 +436,15 @@ mod test {
     fn communicates_parsing_error_given_an_invalid_integerlike_string() {
         let integer_str = Value::test_string("36anra");
 
-        let actual = action(&integer_str, Span::test_data(), 10, false);
+        let actual = action(
+            &integer_str,
+            &Arguments {
+                radix: 10,
+                cell_paths: None,
+                little_endian: false,
+            },
+            Span::test_data(),
+        );
 
         assert_eq!(actual.get_type(), Error)
     }

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

@@ -6,6 +6,7 @@ mod decimal;
 mod duration;
 mod filesize;
 mod int;
+mod record;
 mod string;
 
 pub use self::bool::SubCommand as IntoBool;
@@ -16,4 +17,5 @@ pub use datetime::SubCommand as IntoDatetime;
 pub use decimal::SubCommand as IntoDecimal;
 pub use duration::SubCommand as IntoDuration;
 pub use int::SubCommand as IntoInt;
+pub use record::SubCommand as IntoRecord;
 pub use string::SubCommand as IntoString;

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

@@ -0,0 +1,291 @@
+use chrono::{DateTime, Datelike, FixedOffset, Timelike};
+use nu_protocol::format_duration_as_timeperiod;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Type, Value,
+};
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "into record"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into record")
+            .input_output_types(vec![
+                (Type::Date, Type::Record(vec![])),
+                (Type::Duration, Type::Record(vec![])),
+                (Type::List(Box::new(Type::Any)), Type::Record(vec![])),
+                (Type::Range, Type::Record(vec![])),
+                (Type::Record(vec![]), Type::Record(vec![])),
+                (Type::Table(vec![]), Type::Record(vec![])),
+            ])
+            .category(Category::Conversions)
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to record"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["convert"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        into_record(engine_state, call, input)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        let span = Span::test_data();
+        vec![
+            Example {
+                description: "Convert from one row table to record",
+                example: "echo [[value]; [false]] | into record",
+                result: Some(Value::Record {
+                    cols: vec!["value".to_string()],
+                    vals: vec![Value::boolean(false, span)],
+                    span,
+                }),
+            },
+            Example {
+                description: "Convert from list to record",
+                example: "[1 2 3] | into record",
+                result: Some(Value::Record {
+                    cols: vec!["0".to_string(), "1".to_string(), "2".to_string()],
+                    vals: vec![
+                        Value::Int { val: 1, span },
+                        Value::Int { val: 2, span },
+                        Value::Int { val: 3, span },
+                    ],
+                    span,
+                }),
+            },
+            Example {
+                description: "Convert from range to record",
+                example: "0..2 | into record",
+                result: Some(Value::Record {
+                    cols: vec!["0".to_string(), "1".to_string(), "2".to_string()],
+                    vals: vec![
+                        Value::Int { val: 0, span },
+                        Value::Int { val: 1, span },
+                        Value::Int { val: 2, span },
+                    ],
+                    span,
+                }),
+            },
+            Example {
+                description: "convert duration to record",
+                example: "-500day | into record",
+                result: Some(Value::Record {
+                    cols: vec![
+                        "year".into(),
+                        "month".into(),
+                        "week".into(),
+                        "day".into(),
+                        "sign".into(),
+                    ],
+                    vals: vec![
+                        Value::Int { val: 1, span },
+                        Value::Int { val: 4, span },
+                        Value::Int { val: 2, span },
+                        Value::Int { val: 1, span },
+                        Value::String {
+                            val: "-".into(),
+                            span,
+                        },
+                    ],
+                    span,
+                }),
+            },
+            Example {
+                description: "convert record to record",
+                example: "{a: 1, b: 2} | into record",
+                result: Some(Value::Record {
+                    cols: vec!["a".to_string(), "b".to_string()],
+                    vals: vec![Value::Int { val: 1, span }, Value::Int { val: 2, span }],
+                    span,
+                }),
+            },
+            Example {
+                description: "convert date to record",
+                example: "2020-04-12T22:10:57+02:00 | into record",
+                result: Some(Value::Record {
+                    cols: vec![
+                        "year".into(),
+                        "month".into(),
+                        "day".into(),
+                        "hour".into(),
+                        "minute".into(),
+                        "second".into(),
+                        "timezone".into(),
+                    ],
+                    vals: vec![
+                        Value::Int { val: 2020, span },
+                        Value::Int { val: 4, span },
+                        Value::Int { val: 12, span },
+                        Value::Int { val: 22, span },
+                        Value::Int { val: 10, span },
+                        Value::Int { val: 57, span },
+                        Value::String {
+                            val: "+02:00".to_string(),
+                            span,
+                        },
+                    ],
+                    span,
+                }),
+            },
+        ]
+    }
+}
+
+fn into_record(
+    engine_state: &EngineState,
+    call: &Call,
+    input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let input = input.into_value(call.head);
+    let input_type = input.get_type();
+    let res = match input {
+        Value::Date { val, span } => parse_date_into_record(Ok(val), span),
+        Value::Duration { val, span } => parse_duration_into_record(val, span),
+        Value::List { mut vals, span } => match input_type {
+            Type::Table(..) if vals.len() == 1 => vals.pop().expect("already checked 1 item"),
+            _ => {
+                let mut cols = vec![];
+                let mut values = vec![];
+                for (idx, val) in vals.into_iter().enumerate() {
+                    cols.push(format!("{idx}"));
+                    values.push(val);
+                }
+                Value::Record {
+                    cols,
+                    vals: values,
+                    span,
+                }
+            }
+        },
+        Value::Range { val, span } => {
+            let mut cols = vec![];
+            let mut vals = vec![];
+            for (idx, val) in val.into_range_iter(engine_state.ctrlc.clone())?.enumerate() {
+                cols.push(format!("{idx}"));
+                vals.push(val);
+            }
+            Value::Record { cols, vals, span }
+        }
+        Value::Record { cols, vals, span } => Value::Record { cols, vals, span },
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                "'into record' does not support this input".into(),
+                other.span().unwrap_or(call.head),
+            ),
+        },
+    };
+    Ok(res.into_pipeline_data())
+}
+
+fn parse_date_into_record(date: Result<DateTime<FixedOffset>, Value>, span: Span) -> Value {
+    let cols = vec![
+        "year".into(),
+        "month".into(),
+        "day".into(),
+        "hour".into(),
+        "minute".into(),
+        "second".into(),
+        "timezone".into(),
+    ];
+    match date {
+        Ok(x) => {
+            let vals = vec![
+                Value::Int {
+                    val: x.year() as i64,
+                    span,
+                },
+                Value::Int {
+                    val: x.month() as i64,
+                    span,
+                },
+                Value::Int {
+                    val: x.day() as i64,
+                    span,
+                },
+                Value::Int {
+                    val: x.hour() as i64,
+                    span,
+                },
+                Value::Int {
+                    val: x.minute() as i64,
+                    span,
+                },
+                Value::Int {
+                    val: x.second() as i64,
+                    span,
+                },
+                Value::String {
+                    val: x.offset().to_string(),
+                    span,
+                },
+            ];
+            Value::Record { cols, vals, span }
+        }
+        Err(e) => e,
+    }
+}
+
+fn parse_duration_into_record(duration: i64, span: Span) -> Value {
+    let (sign, periods) = format_duration_as_timeperiod(duration);
+
+    let mut cols = vec![];
+    let mut vals = vec![];
+    for p in periods {
+        let num_with_unit = p.to_text().to_string();
+        let split = num_with_unit.split(' ').collect::<Vec<&str>>();
+        cols.push(match split[1] {
+            "ns" => "nanosecond".into(),
+            "µs" => "microsecond".into(),
+            "ms" => "millisecond".into(),
+            "sec" => "second".into(),
+            "min" => "minute".into(),
+            "hr" => "hour".into(),
+            "day" => "day".into(),
+            "wk" => "week".into(),
+            "month" => "month".into(),
+            "yr" => "year".into(),
+            _ => "unknown".into(),
+        });
+
+        vals.push(Value::Int {
+            val: split[0].parse::<i64>().unwrap_or(0),
+            span,
+        });
+    }
+
+    cols.push("sign".into());
+    vals.push(Value::String {
+        val: if sign == -1 { "-".into() } else { "+".into() },
+        span,
+    });
+
+    Value::Record { cols, vals, span }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

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

@@ -1,12 +1,26 @@
+use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
     into_code, Category, Config, Example, IntoPipelineData, PipelineData, ShellError, Signature,
-    Span, SyntaxShape, Value,
+    Span, SyntaxShape, Type, Value,
 };
+use nu_utils::get_system_locale;
+use num_format::ToFormattedString;
 
-// TODO num_format::SystemLocale once platform-specific dependencies are stable (see Cargo.toml)
+struct Arguments {
+    decimals_value: Option<i64>,
+    decimals: bool,
+    cell_paths: Option<Vec<CellPath>>,
+    config: Config,
+}
+
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
+    }
+}
 
 #[derive(Clone)]
 pub struct SubCommand;
@@ -18,11 +32,20 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into string")
-            // FIXME - need to support column paths
+            .input_output_types(vec![
+                (Type::Binary, Type::String),
+                (Type::Int, Type::String),
+                (Type::Number, Type::String),
+                (Type::String, Type::String),
+                (Type::Bool, Type::String),
+                (Type::Filesize, Type::String),
+                (Type::Date, Type::String),
+            ])
+            .allow_variants_without_examples(true) // https://github.com/nushell/nushell/issues/7032
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "column paths to convert to string (for table input)",
+                "for a data structure input, convert data at the given cell paths",
             )
             .named(
                 "decimals",
@@ -38,7 +61,7 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["convert", "str", "text"]
+        vec!["convert", "text"]
     }
 
     fn run(
@@ -53,6 +76,14 @@ impl Command for SubCommand {
 
     fn examples(&self) -> Vec<Example> {
         vec![
+            Example {
+                description: "convert integer to string and append three decimal places",
+                example: "5 | into string -d 3",
+                result: Some(Value::String {
+                    val: "5.000".to_string(),
+                    span: Span::test_data(),
+                }),
+            },
             Example {
                 description: "convert decimal to string and round to nearest integer",
                 example: "1.7 | into string -d 0",
@@ -113,11 +144,12 @@ impl Command for SubCommand {
                     span: Span::test_data(),
                 }),
             },
-            Example {
-                description: "convert date to string",
-                example: "date now | into string",
-                result: None,
-            },
+            // TODO: This should work but does not; see https://github.com/nushell/nushell/issues/7032
+            // Example {
+            //     description: "convert date to string",
+            //     example: "'2020-10-10 10:00:00 +02:00' | into datetime | into string",
+            //     result: Some(Value::test_string("Sat Oct 10 10:00:00 2020")),
+            // },
             Example {
                 description: "convert filepath to string",
                 example: "ls Cargo.toml | get name | into string",
@@ -125,8 +157,8 @@ impl Command for SubCommand {
             },
             Example {
                 description: "convert filesize to string",
-                example: "ls Cargo.toml | get size | into string",
-                result: None,
+                example: "1KiB | into string",
+                result: Some(Value::test_string("1,024 B")),
             },
         ]
     }
@@ -141,9 +173,6 @@ fn string_helper(
     let decimals = call.has_flag("decimals");
     let head = call.head;
     let decimals_value: Option<i64> = call.get_flag(engine_state, stack, "decimals")?;
-    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-    let config = engine_state.get_config().clone();
-
     if let Some(decimal_val) = decimals_value {
         if decimals && decimal_val.is_negative() {
             return Err(ShellError::UnsupportedInput(
@@ -152,6 +181,15 @@ fn string_helper(
             ));
         }
     }
+    let cell_paths = call.rest(engine_state, stack, 0)?;
+    let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+    let config = engine_state.get_config().clone();
+    let args = Arguments {
+        decimals_value,
+        decimals,
+        cell_paths,
+        config,
+    };
 
     match input {
         PipelineData::ExternalStream { stdout: None, .. } => Ok(Value::String {
@@ -171,49 +209,18 @@ fn string_helper(
             }
             .into_pipeline_data())
         }
-        _ => input.map(
-            move |v| {
-                if column_paths.is_empty() {
-                    action(&v, head, decimals, decimals_value, false, &config)
-                } else {
-                    let mut ret = v;
-                    for path in &column_paths {
-                        let config = config.clone();
-                        let r = ret.update_cell_path(
-                            &path.members,
-                            Box::new(move |old| {
-                                action(old, head, decimals, decimals_value, false, &config)
-                            }),
-                        );
-                        if let Err(error) = r {
-                            return Value::Error { error };
-                        }
-                    }
-
-                    ret
-                }
-            },
-            engine_state.ctrlc.clone(),
-        ),
+        _ => operate(action, args, input, head, engine_state.ctrlc.clone()),
     }
 }
 
-pub fn action(
-    input: &Value,
-    span: Span,
-    decimals: bool,
-    digits: Option<i64>,
-    group_digits: bool,
-    config: &Config,
-) -> Value {
+fn action(input: &Value, args: &Arguments, span: Span) -> Value {
+    let decimals = args.decimals;
+    let digits = args.decimals_value;
+    let config = &args.config;
     match input {
         Value::Int { val, .. } => {
-            let res = if group_digits {
-                format_int(*val) // int.to_formatted_string(*locale)
-            } else {
-                val.to_string()
-            };
-
+            let decimal_value = digits.unwrap_or(0) as usize;
+            let res = format_int(*val, false, decimal_value);
             Value::String { val: res, span }
         }
         Value::Float { val, .. } => {
@@ -288,21 +295,29 @@ pub fn action(
         },
     }
 }
-fn format_int(int: i64) -> String {
-    int.to_string()
 
-    // TODO once platform-specific dependencies are stable (see Cargo.toml)
-    // #[cfg(windows)]
-    // {
-    //     int.to_formatted_string(&Locale::en)
-    // }
-    // #[cfg(not(windows))]
-    // {
-    //     match SystemLocale::default() {
-    //         Ok(locale) => int.to_formatted_string(&locale),
-    //         Err(_) => int.to_formatted_string(&Locale::en),
-    //     }
-    // }
+fn format_int(int: i64, group_digits: bool, decimals: usize) -> String {
+    let locale = get_system_locale();
+
+    let str = if group_digits {
+        int.to_formatted_string(&locale)
+    } else {
+        int.to_string()
+    };
+
+    if decimals > 0 {
+        let decimal_point = locale.decimal();
+
+        format!(
+            "{}{decimal_point}{dummy:0<decimals$}",
+            str,
+            decimal_point = decimal_point,
+            dummy = "",
+            decimals = decimals
+        )
+    } else {
+        str
+    }
 }
 
 #[cfg(test)]

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

@@ -1,6 +1,6 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape};
+use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Type, Value};
 
 #[derive(Clone)]
 pub struct Alias;
@@ -16,6 +16,7 @@ impl Command for Alias {
 
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("alias")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
             .required("name", SyntaxShape::String, "name of the alias")
             .required(
                 "initial_value",
@@ -27,7 +28,7 @@ impl Command for Alias {
 
     fn extra_usage(&self) -> &str {
         r#"This command is a parser keyword. For details, check:
-  https://www.nushell.sh/book/thinking_in_nushell.html"#
+  https://www.nushell.sh/book/thinking_in_nu.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {
@@ -49,10 +50,17 @@ impl Command for Alias {
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Alias ll to ls -l",
-            example: "alias ll = ls -l",
-            result: None,
-        }]
+        vec![
+            Example {
+                description: "Alias ll to ls -l",
+                example: "alias ll = ls -l",
+                result: Some(Value::nothing(Span::test_data())),
+            },
+            Example {
+                description: "Make an alias that makes a list of all custom commands",
+                example: "alias customs = ($nu.scope.commands | where is_custom | get command)",
+                result: Some(Value::nothing(Span::test_data())),
+            },
+        ]
     }
 }

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

@@ -0,0 +1,79 @@
+use nu_engine::CallExt;
+use nu_parser::parse;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack, StateWorkingSet},
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type,
+    Value,
+};
+
+#[derive(Clone)]
+pub struct Ast;
+
+impl Command for Ast {
+    fn name(&self) -> &str {
+        "ast"
+    }
+
+    fn usage(&self) -> &str {
+        "Print the abstract syntax tree (ast) for a pipeline."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("ast")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .required(
+                "pipeline",
+                SyntaxShape::String,
+                "the pipeline to print the ast for",
+            )
+            .category(Category::Core)
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        let pipeline: Spanned<String> = call.req(engine_state, stack, 0)?;
+        let mut working_set = StateWorkingSet::new(engine_state);
+
+        let (output, err) = parse(&mut working_set, None, pipeline.item.as_bytes(), false, &[]);
+        eprintln!("output: {:#?}\nerror: {:#?}", output, err);
+
+        Ok(PipelineData::new(head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Print the ast of a string",
+                example: "ast 'hello'",
+                result: Some(Value::nothing(Span::test_data())),
+            },
+            Example {
+                description: "Print the ast of a pipeline",
+                example: "ast 'ls | where name =~ README'",
+                result: Some(Value::nothing(Span::test_data())),
+            },
+            Example {
+                description: "Print the ast of a pipeline with an error",
+                example: "ast 'for x in 1..10 { echo $x '",
+                result: Some(Value::nothing(Span::test_data())),
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_examples() {
+        use super::Ast;
+        use crate::test_examples;
+        test_examples(Ast {})
+    }
+}

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

@@ -0,0 +1,49 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Type};
+
+#[derive(Clone)]
+pub struct Break;
+
+impl Command for Break {
+    fn name(&self) -> &str {
+        "break"
+    }
+
+    fn usage(&self) -> &str {
+        "Break a loop"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("break")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .category(Category::Core)
+    }
+
+    fn extra_usage(&self) -> &str {
+        r#"This command is a parser keyword. For details, check:
+  https://www.nushell.sh/book/thinking_in_nu.html"#
+    }
+
+    fn is_parser_keyword(&self) -> bool {
+        true
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Err(ShellError::Break(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Break out of a loop",
+            example: r#"loop { break }"#,
+            result: None,
+        }]
+    }
+}

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

@@ -0,0 +1,85 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::ReplOperation;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::Category;
+use nu_protocol::IntoPipelineData;
+use nu_protocol::{PipelineData, ShellError, Signature, SyntaxShape, Type, Value};
+
+#[derive(Clone)]
+pub struct Commandline;
+
+impl Command for Commandline {
+    fn name(&self) -> &str {
+        "commandline"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("commandline")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .switch(
+                "append",
+                "appends the string to the end of the buffer",
+                Some('a'),
+            )
+            .switch(
+                "insert",
+                "inserts the string into the buffer at the cursor position",
+                Some('i'),
+            )
+            .switch(
+                "replace",
+                "replaces the current contents of the buffer (default)",
+                Some('r'),
+            )
+            .optional(
+                "cmd",
+                SyntaxShape::String,
+                "the string to perform the operation with",
+            )
+            .category(Category::Core)
+    }
+
+    fn usage(&self) -> &str {
+        "View or modify the current command line input buffer"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["repl", "interactive"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        if let Some(cmd) = call.opt::<Value>(engine_state, stack, 0)? {
+            let mut ops = engine_state
+                .repl_operation_queue
+                .lock()
+                .expect("repl op queue mutex");
+            ops.push_back(if call.has_flag("append") {
+                ReplOperation::Append(cmd.as_string()?)
+            } else if call.has_flag("insert") {
+                ReplOperation::Insert(cmd.as_string()?)
+            } else {
+                ReplOperation::Replace(cmd.as_string()?)
+            });
+            Ok(Value::Nothing { span: call.head }.into_pipeline_data())
+        } else if let Some(ref cmd) = *engine_state
+            .repl_buffer_state
+            .lock()
+            .expect("repl buffer state mutex")
+        {
+            Ok(Value::String {
+                val: cmd.clone(),
+                span: call.head,
+            }
+            .into_pipeline_data())
+        } else {
+            Ok(Value::Nothing { span: call.head }.into_pipeline_data())
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Type};
+
+#[derive(Clone)]
+pub struct Continue;
+
+impl Command for Continue {
+    fn name(&self) -> &str {
+        "continue"
+    }
+
+    fn usage(&self) -> &str {
+        "Continue a loop from the next iteration"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("continue")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .category(Category::Core)
+    }
+
+    fn extra_usage(&self) -> &str {
+        r#"This command is a parser keyword. For details, check:
+  https://www.nushell.sh/book/thinking_in_nu.html"#
+    }
+
+    fn is_parser_keyword(&self) -> bool {
+        true
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Err(ShellError::Continue(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Continue a loop from the next iteration",
+            example: r#"for i in 1..10 { if $i == 5 { continue }; print $i }"#,
+            result: None,
+        }]
+    }
+}

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

@@ -1,6 +1,6 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Span, Value};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Span, Type, Value};
 
 #[derive(Clone)]
 pub struct Debug;
@@ -15,11 +15,17 @@ impl Command for Debug {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("debug").category(Category::Core).switch(
-            "raw",
-            "Prints the raw value representation",
-            Some('r'),
-        )
+        Signature::build("debug")
+            .input_output_types(vec![
+                (
+                    Type::List(Box::new(Type::Any)),
+                    Type::List(Box::new(Type::String)),
+                ),
+                (Type::Table(vec![]), Type::List(Box::new(Type::String))),
+                (Type::Any, Type::String),
+            ])
+            .category(Category::Core)
+            .switch("raw", "Prints the raw value representation", Some('r'))
     }
 
     fn run(
@@ -54,12 +60,20 @@ impl Command for Debug {
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
-                description: "Print the value of a string",
+                description: "Debug print a string",
                 example: "'hello' | debug",
                 result: Some(Value::test_string("hello")),
             },
             Example {
-                description: "Print the value of a table",
+                description: "Debug print a list",
+                example: "['hello'] | debug",
+                result: Some(Value::List {
+                    vals: vec![Value::test_string("hello")],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Debug print a table",
                 example: "echo [[version patch]; [0.1.0 false] [0.1.1 true] [0.2.0 false]] | debug",
                 result: Some(Value::List {
                     vals: vec![

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

@@ -1,6 +1,6 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Value};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Type, Value};
 
 #[derive(Clone)]
 pub struct Def;
@@ -16,19 +16,16 @@ impl Command for Def {
 
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("def")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
             .required("def_name", SyntaxShape::String, "definition name")
             .required("params", SyntaxShape::Signature, "parameters")
-            .required(
-                "block",
-                SyntaxShape::Block(Some(vec![])),
-                "body of the definition",
-            )
+            .required("body", SyntaxShape::Closure(None), "body of the definition")
             .category(Category::Core)
     }
 
     fn extra_usage(&self) -> &str {
         r#"This command is a parser keyword. For details, check:
-  https://www.nushell.sh/book/thinking_in_nushell.html"#
+  https://www.nushell.sh/book/thinking_in_nu.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -1,6 +1,6 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Value};
+use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Type, Value};
 
 #[derive(Clone)]
 pub struct DefEnv;
@@ -16,19 +16,16 @@ impl Command for DefEnv {
 
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("def-env")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
             .required("def_name", SyntaxShape::String, "definition name")
             .required("params", SyntaxShape::Signature, "parameters")
-            .required(
-                "block",
-                SyntaxShape::Block(Some(vec![])),
-                "body of the definition",
-            )
+            .required("block", SyntaxShape::Block, "body of the definition")
             .category(Category::Core)
     }
 
     fn extra_usage(&self) -> &str {
         r#"This command is a parser keyword. For details, check:
-  https://www.nushell.sh/book/thinking_in_nushell.html
+  https://www.nushell.sh/book/thinking_in_nu.html
 
 === EXTRA NOTE ===
 All blocks are scoped, including variable definition and environment variable changes.

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

@@ -1,7 +1,7 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Value,
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Type, Value,
 };
 
 #[derive(Clone)]
@@ -17,7 +17,9 @@ impl Command for Describe {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("describe").category(Category::Core)
+        Signature::build("describe")
+            .input_output_types(vec![(Type::Any, Type::String)])
+            .category(Category::Core)
     }
 
     fn run(

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

@@ -1,8 +1,8 @@
-use nu_engine::{eval_block, CallExt};
+use nu_engine::{eval_block_with_early_return, CallExt};
 use nu_protocol::ast::Call;
-use nu_protocol::engine::{CaptureBlock, Command, EngineState, Stack};
+use nu_protocol::engine::{Closure, Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, IntoPipelineData, PipelineData, Signature, SyntaxShape, Value,
+    Category, Example, ListStream, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
 };
 
 #[derive(Clone)]
@@ -17,14 +17,25 @@ impl Command for Do {
         "Run a block"
     }
 
-    fn signature(&self) -> nu_protocol::Signature {
+    fn signature(&self) -> Signature {
         Signature::build("do")
-            .required("block", SyntaxShape::Any, "the block to run")
+            .required("closure", SyntaxShape::Any, "the closure to run")
+            .input_output_types(vec![(Type::Any, Type::Any)])
             .switch(
                 "ignore-errors",
                 "ignore errors as the block runs",
                 Some('i'),
             )
+            .switch(
+                "ignore-shell-errors",
+                "ignore shell errors as the block runs",
+                Some('s'),
+            )
+            .switch(
+                "ignore-program-errors",
+                "ignore program errors as the block runs",
+                Some('p'),
+            )
             .switch(
                 "capture-errors",
                 "capture errors as the block runs and return it",
@@ -40,10 +51,12 @@ impl Command for Do {
         stack: &mut Stack,
         call: &Call,
         input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let block: CaptureBlock = call.req(engine_state, stack, 0)?;
+    ) -> Result<PipelineData, ShellError> {
+        let block: Closure = call.req(engine_state, stack, 0)?;
         let rest: Vec<Value> = call.rest(engine_state, stack, 1)?;
-        let ignore_errors = call.has_flag("ignore-errors");
+        let ignore_all_errors = call.has_flag("ignore-errors");
+        let ignore_shell_errors = ignore_all_errors || call.has_flag("ignore-shell-errors");
+        let ignore_program_errors = ignore_all_errors || call.has_flag("ignore-program-errors");
         let capture_errors = call.has_flag("capture-errors");
 
         let mut stack = stack.captures_to_stack(&block.captures);
@@ -87,27 +100,79 @@ impl Command for Do {
                 )
             }
         }
-        let result = eval_block(
+        let result = eval_block_with_early_return(
             engine_state,
             &mut stack,
             block,
             input,
             call.redirect_stdout,
-            ignore_errors || capture_errors,
+            capture_errors || ignore_shell_errors || ignore_program_errors,
         );
 
-        if ignore_errors {
-            match result {
-                Ok(x) => Ok(x),
-                Err(_) => Ok(PipelineData::new(call.head)),
+        match result {
+            Ok(PipelineData::ExternalStream {
+                stdout,
+                stderr,
+                exit_code,
+                span,
+                metadata,
+                trim_end_newline,
+            }) if capture_errors => {
+                let mut exit_code_ctrlc = None;
+                let exit_code: Vec<Value> = match exit_code {
+                    None => vec![],
+                    Some(exit_code_stream) => {
+                        exit_code_ctrlc = exit_code_stream.ctrlc.clone();
+                        exit_code_stream.into_iter().collect()
+                    }
+                };
+                if let Some(Value::Int { val: code, .. }) = exit_code.last() {
+                    if *code != 0 {
+                        let stderr_msg = match stderr {
+                            None => "".to_string(),
+                            Some(stderr_stream) => stderr_stream.into_string().map(|s| s.item)?,
+                        };
+
+                        return Err(ShellError::ExternalCommand(
+                            "External command failed".to_string(),
+                            stderr_msg,
+                            span,
+                        ));
+                    }
+                }
+
+                Ok(PipelineData::ExternalStream {
+                    stdout,
+                    stderr,
+                    exit_code: Some(ListStream::from_stream(
+                        exit_code.into_iter(),
+                        exit_code_ctrlc,
+                    )),
+                    span,
+                    metadata,
+                    trim_end_newline,
+                })
             }
-        } else if capture_errors {
-            match result {
-                Ok(x) => Ok(x),
-                Err(err) => Ok((Value::Error { error: err }).into_pipeline_data()),
+            Ok(PipelineData::ExternalStream {
+                stdout,
+                stderr,
+                exit_code: _,
+                span,
+                metadata,
+                trim_end_newline,
+            }) if ignore_program_errors => Ok(PipelineData::ExternalStream {
+                stdout,
+                stderr,
+                exit_code: None,
+                span,
+                metadata,
+                trim_end_newline,
+            }),
+            Ok(PipelineData::Value(Value::Error { .. }, ..)) if ignore_shell_errors => {
+                Ok(PipelineData::new(call.head))
             }
-        } else {
-            result
+            Err(_) if ignore_shell_errors => Ok(PipelineData::new(call.head)),
+            r => r,
         }
     }
 
@@ -119,14 +184,34 @@ impl Command for Do {
                 result: Some(Value::test_string("hello")),
             },
             Example {
-                description: "Run the block and ignore errors",
+                description: "Run the block and ignore both shell and program errors",
                 example: r#"do -i { thisisnotarealcommand }"#,
                 result: None,
             },
+            Example {
+                description: "Run the block and ignore shell errors",
+                example: r#"do -s { thisisnotarealcommand }"#,
+                result: None,
+            },
+            Example {
+                description: "Run the block and ignore program errors",
+                example: r#"do -p { nu -c 'exit 1' }; echo "I'll still run""#,
+                result: None,
+            },
+            Example {
+                description: "Abort the pipeline if a program returns a non-zero exit code",
+                example: r#"do -c { nu -c 'exit 1' } | myscarycommand"#,
+                result: None,
+            },
             Example {
                 description: "Run the block, with a positional parameter",
-                example: r#"do {|x| 100 + $x } 50"#,
-                result: Some(Value::test_int(150)),
+                example: r#"do {|x| 100 + $x } 77"#,
+                result: Some(Value::test_int(177)),
+            },
+            Example {
+                description: "Run the block, with input",
+                example: r#"77 | do {|x| 100 + $in }"#,
+                result: None, // TODO: returns 177
             },
         ]
     }