Bump version to 0.92.2 (#12402)

Encountered repeated build failure that vanished after clearing the
existing build caches.

- Don't `fail-fast` (this is highly annoying, if a severe problem is
detected, there is still the possibility to intervene manually)
- Don't cache the build process, we do it rarely so any potential
speed-up is offset by the uncertainty if this affects the artefact

.github/pull_request_template.md

@@ -26,7 +26,7 @@ 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` to check that you're using the standard code style
 - `cargo test --workspace` to check that all tests pass (on Windows make sure to [enable developer mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging))
-- `cargo run -- -c "use toolkit.nu; toolkit test stdlib"` to run the tests for the standard library
+- `cargo run -- -c "use std testing; testing run-tests --path crates/nu-std"` to run the tests for the standard library
 
 > **Note**
 > from `nushell` you can also use the `toolkit` as follows

.github/workflows/audit.yml

@@ -19,7 +19,7 @@ jobs:
     # Prevent sudden announcement of a new advisory from failing ci:
     continue-on-error: true
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v4.1.2
       - uses: rustsec/audit-check@v1.4.1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ env:
   NUSHELL_CARGO_PROFILE: ci
   NU_LOG_LEVEL: DEBUG
   # If changing these settings also change toolkit.nu
-  CLIPPY_OPTIONS: "-D warnings -D clippy::unwrap_used -D clippy::unchecked_duration_subtraction"
+  CLIPPY_OPTIONS: "-D warnings -D clippy::unwrap_used"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
@@ -24,55 +24,77 @@ jobs:
         # Pinning to Ubuntu 20.04 because building on newer Ubuntu versions causes linux-gnu
         # builds to link against a too-new-for-many-Linux-installs glibc version. Consider
         # revisiting this when 20.04 is closer to EOL (April 2025)
-        #
+        platform: [windows-latest, macos-latest, ubuntu-20.04]
-        # Using macOS 13 runner because 14 is based on the M1 and has half as much RAM (7 GB,
+        feature: [default, dataframe]
-        # instead of 14 GB) which is too little for us right now. Revisit when `dfr` commands are
+        include:
-        # removed and we're only building the `polars` plugin instead
+          - feature: default
-        platform: [windows-latest, macos-13, ubuntu-20.04]
+            flags: ""
+          - feature: dataframe
+            flags: "--features=dataframe"
+        exclude:
+          - platform: windows-latest
+            feature: dataframe
+          - platform: macos-latest
+            feature: dataframe
 
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v4.1.2
 
       - name: Setup Rust toolchain and cache
         uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
+        with:
+          rustflags: ""
 
       - name: cargo fmt
         run: cargo fmt --all -- --check
 
         # If changing these settings also change toolkit.nu
       - name: Clippy
-        run: cargo clippy --workspace --exclude nu_plugin_* -- $CLIPPY_OPTIONS
+        run: cargo clippy --workspace ${{ matrix.flags }} --exclude nu_plugin_* -- $CLIPPY_OPTIONS
 
         # In tests we don't have to deny unwrap
       - name: Clippy of tests
-        run: cargo clippy --tests --workspace --exclude nu_plugin_* -- -D warnings
+        run: cargo clippy --tests --workspace ${{ matrix.flags }} --exclude nu_plugin_* -- -D warnings
 
       - name: Clippy of benchmarks
-        run: cargo clippy --benches --workspace --exclude nu_plugin_* -- -D warnings
+        run: cargo clippy --benches --workspace ${{ matrix.flags }} --exclude nu_plugin_* -- -D warnings
 
   tests:
     strategy:
       fail-fast: true
       matrix:
         platform: [windows-latest, macos-latest, ubuntu-20.04]
+        feature: [default, dataframe]
         include:
-          - default-flags: ""
           # linux CI cannot handle clipboard feature
-          - platform: ubuntu-20.04
+          - default-flags: ""
+          - platform:  ubuntu-20.04
             default-flags: "--no-default-features --features=default-no-clipboard"
+          - feature: default
+            flags: ""
+          - feature: dataframe
+            flags: "--features=dataframe"
+        exclude:
+          - platform: windows-latest
+            feature: dataframe
+          - platform: macos-latest
+            feature: dataframe
 
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v4.1.2
 
       - name: Setup Rust toolchain and cache
         uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
+        with:
+          rustflags: ""
 
       - name: Tests
-        run: cargo test --workspace --profile ci --exclude nu_plugin_* ${{ matrix.default-flags }}
+        run: cargo test --workspace --profile ci --exclude nu_plugin_* ${{ matrix.default-flags }} ${{ matrix.flags }}
+
       - name: Check for clean repo
         shell: bash
         run: |
@@ -95,10 +117,12 @@ jobs:
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v4.1.2
 
       - name: Setup Rust toolchain and cache
         uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
+        with:
+          rustflags: ""
 
       - name: Install Nushell
         run: cargo install --path . --locked --no-default-features
@@ -137,19 +161,17 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        # Using macOS 13 runner because 14 is based on the M1 and has half as much RAM (7 GB,
+        platform: [windows-latest, macos-latest, ubuntu-20.04]
-        # instead of 14 GB) which is too little for us right now.
-        #
-        # Failure occurring with clippy for rust 1.77.2
-        platform: [windows-latest, macos-13, ubuntu-20.04]
 
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v4.1.2
 
       - name: Setup Rust toolchain and cache
         uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
+        with:
+          rustflags: ""
 
       - name: Clippy
         run: cargo clippy --package nu_plugin_* -- $CLIPPY_OPTIONS

.github/workflows/nightly-build.yml

@@ -27,7 +27,7 @@ jobs:
     # if: github.repository == 'nushell/nightly'
     steps:
       - name: Checkout
-        uses: actions/checkout@v4.1.6
+        uses: actions/checkout@v4.1.2
         if: github.repository == 'nushell/nightly'
         with:
           ref: main
@@ -36,10 +36,10 @@ jobs:
           token: ${{ secrets.WORKFLOW_TOKEN }}
 
       - name: Setup Nushell
-        uses: hustcer/setup-nu@v3.10
+        uses: hustcer/setup-nu@v3.9
         if: github.repository == 'nushell/nightly'
         with:
-          version: 0.93.0
+          version: 0.91.0
 
       # Synchronize the main branch of nightly repo with the main branch of Nushell official repo
       - name: Prepare for Nightly Release
@@ -84,35 +84,46 @@ jobs:
         include:
         - target: aarch64-apple-darwin
           os: macos-latest
+          target_rustflags: ''
         - target: x86_64-apple-darwin
           os: macos-latest
+          target_rustflags: ''
         - target: x86_64-pc-windows-msvc
           extra: 'bin'
           os: windows-latest
+          target_rustflags: ''
         - target: x86_64-pc-windows-msvc
           extra: msi
           os: windows-latest
+          target_rustflags: ''
         - target: aarch64-pc-windows-msvc
           extra: 'bin'
           os: windows-latest
+          target_rustflags: ''
         - target: aarch64-pc-windows-msvc
           extra: msi
           os: windows-latest
+          target_rustflags: ''
         - target: x86_64-unknown-linux-gnu
           os: ubuntu-20.04
+          target_rustflags: ''
         - target: x86_64-unknown-linux-musl
           os: ubuntu-20.04
+          target_rustflags: ''
         - target: aarch64-unknown-linux-gnu
           os: ubuntu-20.04
+          target_rustflags: ''
         - target: armv7-unknown-linux-gnueabihf
           os: ubuntu-20.04
+          target_rustflags: ''
         - target: riscv64gc-unknown-linux-gnu
           os: ubuntu-latest
+          target_rustflags: ''
 
     runs-on: ${{matrix.os}}
 
     steps:
-    - uses: actions/checkout@v4.1.6
+    - uses: actions/checkout@v4.1.2
       with:
         ref: main
         fetch-depth: 0
@@ -123,23 +134,25 @@ jobs:
 
     - name: Setup Rust toolchain and cache
       uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
-      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec: Error 0xc0000135`
+      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec:  Error 0xc0000135`
       with:
         rustflags: ''
 
     - name: Setup Nushell
-      uses: hustcer/setup-nu@v3.10
+      uses: hustcer/setup-nu@v3.9
       with:
-        version: 0.93.0
+        version: 0.91.0
 
     - name: Release Nu Binary
       id: nu
       run: nu .github/workflows/release-pkg.nu
       env:
+        RELEASE_TYPE: standard
         OS: ${{ matrix.os }}
         REF: ${{ github.ref }}
         TARGET: ${{ matrix.target }}
         _EXTRA_: ${{ matrix.extra }}
+        TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
 
     - name: Create an Issue for Release Failure
       if: ${{ failure() }}
@@ -161,7 +174,7 @@ jobs:
     # REF: https://github.com/marketplace/actions/gh-release
     # Create a release only in nushell/nightly repo
     - name: Publish Archive
-      uses: softprops/action-gh-release@v2.0.5
+      uses: softprops/action-gh-release@v2.0.4
       if: ${{ startsWith(github.repository, 'nushell/nightly') }}
       with:
         prerelease: true
@@ -171,6 +184,122 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+  full:
+    name: Full
+    needs: prepare
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+        - aarch64-apple-darwin
+        - x86_64-apple-darwin
+        - x86_64-pc-windows-msvc
+        - aarch64-pc-windows-msvc
+        - x86_64-unknown-linux-gnu
+        - x86_64-unknown-linux-musl
+        - aarch64-unknown-linux-gnu
+        extra: ['bin']
+        include:
+        - target: aarch64-apple-darwin
+          os: macos-latest
+          target_rustflags: '--features=dataframe'
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: '--features=dataframe'
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe'
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe'
+        - target: aarch64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe'
+        - target: aarch64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe'
+        - target: x86_64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe'
+        - target: x86_64-unknown-linux-musl
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe'
+        - target: aarch64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe'
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+    - uses: actions/checkout@v4.1.2
+      with:
+        ref: main
+        fetch-depth: 0
+
+    - name: Update Rust Toolchain Target
+      run: |
+        echo "targets = ['${{matrix.target}}']" >> rust-toolchain.toml
+
+    - name: Setup Rust toolchain and cache
+      uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
+      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec:  Error 0xc0000135`
+      with:
+        rustflags: ''
+
+    - name: Setup Nushell
+      uses: hustcer/setup-nu@v3.9
+      with:
+        version: 0.91.0
+
+    - name: Release Nu Binary
+      id: nu
+      run: nu .github/workflows/release-pkg.nu
+      env:
+        RELEASE_TYPE: full
+        OS: ${{ matrix.os }}
+        REF: ${{ github.ref }}
+        TARGET: ${{ matrix.target }}
+        _EXTRA_: ${{ matrix.extra }}
+        TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
+
+    - name: Create an Issue for Release Failure
+      if: ${{ failure() }}
+      uses: JasonEtco/create-an-issue@v2.9.2
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        update_existing: true
+        search_existing: open
+        filename: .github/AUTO_ISSUE_TEMPLATE/nightly-build-fail.md
+
+    - name: Set Outputs of Short SHA
+      id: vars
+      run: |
+        echo "date=$(date -u +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+        sha_short=$(git rev-parse --short HEAD)
+        echo "sha_short=${sha_short:0:7}" >> $GITHUB_OUTPUT
+
+    # REF: https://github.com/marketplace/actions/gh-release
+    # Create a release only in nushell/nightly repo
+    - name: Publish Archive
+      uses: softprops/action-gh-release@v2.0.4
+      if: ${{ startsWith(github.repository, 'nushell/nightly') }}
+      with:
+        draft: false
+        prerelease: true
+        name: Nu-nightly-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.sha_short }}
+        tag_name: nightly-${{ steps.vars.outputs.sha_short }}
+        body: |
+          This is a NIGHTLY build of Nushell.
+          It is NOT recommended for production use.
+        files: ${{ steps.nu.outputs.archive }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
   cleanup:
     name: Cleanup
     # Should only run in nushell/nightly repo
@@ -181,14 +310,14 @@ jobs:
       - name: Waiting for Release
         run: sleep 1800
 
-      - uses: actions/checkout@v4.1.6
+      - uses: actions/checkout@v4.1.2
         with:
           ref: main
 
       - name: Setup Nushell
-        uses: hustcer/setup-nu@v3.10
+        uses: hustcer/setup-nu@v3.9
         with:
-          version: 0.93.0
+          version: 0.91.0
 
       # Keep the last a few releases
       - name: Delete Older Releases

.github/workflows/release-pkg.nu

@@ -9,6 +9,7 @@
 # Instructions for manually creating an MSI for Winget Releases when they fail
 # Added 2022-11-29 when Windows packaging wouldn't work
 # Updated again on 2023-02-23 because msis are still failing validation
+# Update on 2023-10-18 to use RELEASE_TYPE env var to determine if full or not
 # To run this manual for windows here are the steps I take
 # checkout the release you want to publish
 # 1. git checkout 0.86.0
@@ -16,26 +17,28 @@
 # 2. $env:CARGO_TARGET_DIR = ""
 # 2. hide-env CARGO_TARGET_DIR
 # 3. $env.TARGET = 'x86_64-pc-windows-msvc'
-# 4. $env.GITHUB_WORKSPACE = 'D:\nushell'
+# 4. $env.TARGET_RUSTFLAGS = ''
-# 5. $env.GITHUB_OUTPUT = 'D:\nushell\output\out.txt'
+# 5. $env.GITHUB_WORKSPACE = 'D:\nushell'
-# 6. $env.OS = 'windows-latest'
+# 6. $env.GITHUB_OUTPUT = 'D:\nushell\output\out.txt'
+# 7. $env.OS = 'windows-latest'
+# 8. $env.RELEASE_TYPE = '' # There is full and '' for normal releases
 # make sure 7z.exe is in your path https://www.7-zip.org/download.html
-# 7. $env.Path = ($env.Path | append 'c:\apps\7-zip')
+# 9. $env.Path = ($env.Path | append 'c:\apps\7-zip')
 # make sure aria2c.exe is in your path https://github.com/aria2/aria2
-# 8. $env.Path = ($env.Path | append 'c:\path\to\aria2c')
+# 10. $env.Path = ($env.Path | append 'c:\path\to\aria2c')
 # make sure you have the wixtools installed https://wixtoolset.org/
-# 9. $env.Path = ($env.Path | append 'C:\Users\dschroeder\AppData\Local\tauri\WixTools')
+# 11. $env.Path = ($env.Path | append 'C:\Users\dschroeder\AppData\Local\tauri\WixTools')
 # You need to run the release-pkg twice. The first pass, with _EXTRA_ as 'bin', makes the output
 # folder and builds everything. The second pass, that generates the msi file, with _EXTRA_ as 'msi'
-# 10. $env._EXTRA_ = 'bin'
+# 12. $env._EXTRA_ = 'bin'
-# 11. source .github\workflows\release-pkg.nu
+# 13. source .github\workflows\release-pkg.nu
-# 12. cd ..
+# 14. cd ..
-# 13. $env._EXTRA_ = 'msi'
+# 15. $env._EXTRA_ = 'msi'
-# 14. source .github\workflows\release-pkg.nu
+# 16. source .github\workflows\release-pkg.nu
 # After msi is generated, you have to update winget-pkgs repo, you'll need to patch the release
 # by deleting the existing msi and uploading this new msi. Then you'll need to update the hash
 # on the winget-pkgs PR. To generate the hash, run this command
-# 15. open target\wix\nu-0.74.0-x86_64-pc-windows-msvc.msi | hash sha256
+# 17. open target\wix\nu-0.74.0-x86_64-pc-windows-msvc.msi | hash sha256
 # Then, just take the output and put it in the winget-pkgs PR for the hash on the msi
 
 
@@ -45,15 +48,31 @@ let os = $env.OS
 let target = $env.TARGET
 # Repo source dir like `/home/runner/work/nushell/nushell`
 let src = $env.GITHUB_WORKSPACE
+let flags = $env.TARGET_RUSTFLAGS
 let dist = $'($env.GITHUB_WORKSPACE)/output'
 let version = (open Cargo.toml | get package.version)
 
 print $'Debugging info:'
-print { version: $version, bin: $bin, os: $os, target: $target, src: $src, dist: $dist }; hr-line -b
+print { version: $version, bin: $bin, os: $os, releaseType: $env.RELEASE_TYPE, target: $target, src: $src, flags: $flags, dist: $dist }; hr-line -b
+
+# Rename the full release name so that we won't break the existing scripts for standard release downloading, such as:
+# curl -s https://api.github.com/repos/chmln/sd/releases/latest | grep browser_download_url | cut -d '"' -f 4 | grep x86_64-unknown-linux-musl
+const FULL_RLS_NAMING = {
+    x86_64-apple-darwin: 'x86_64-darwin-full',
+    aarch64-apple-darwin: 'aarch64-darwin-full',
+    x86_64-unknown-linux-gnu: 'x86_64-linux-gnu-full',
+    x86_64-pc-windows-msvc: 'x86_64-windows-msvc-full',
+    x86_64-unknown-linux-musl: 'x86_64-linux-musl-full',
+    aarch64-unknown-linux-gnu: 'aarch64-linux-gnu-full',
+    aarch64-pc-windows-msvc: 'aarch64-windows-msvc-full',
+    riscv64gc-unknown-linux-gnu: 'riscv64-linux-gnu-full',
+    armv7-unknown-linux-gnueabihf: 'armv7-linux-gnueabihf-full',
+}
 
 # $env
 
 let USE_UBUNTU = $os starts-with ubuntu
+let FULL_NAME = $FULL_RLS_NAMING | get -i $target | default 'unknown-target-full'
 
 print $'(char nl)Packaging ($bin) v($version) for ($target) in ($src)...'; hr-line -b
 if not ('Cargo.lock' | path exists) { cargo generate-lockfile }
@@ -72,23 +91,23 @@ if $os in ['macos-latest'] or $USE_UBUNTU {
         'aarch64-unknown-linux-gnu' => {
             sudo apt-get install gcc-aarch64-linux-gnu -y
             $env.CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER = 'aarch64-linux-gnu-gcc'
-            cargo-build-nu
+            cargo-build-nu $flags
         }
         'riscv64gc-unknown-linux-gnu' => {
             sudo apt-get install gcc-riscv64-linux-gnu -y
             $env.CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER = 'riscv64-linux-gnu-gcc'
-            cargo-build-nu
+            cargo-build-nu $flags
         }
         'armv7-unknown-linux-gnueabihf' => {
             sudo apt-get install pkg-config gcc-arm-linux-gnueabihf -y
             $env.CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER = 'arm-linux-gnueabihf-gcc'
-            cargo-build-nu
+            cargo-build-nu $flags
         }
         _ => {
             # musl-tools to fix 'Failed to find tool. Is `musl-gcc` installed?'
             # Actually just for x86_64-unknown-linux-musl target
             if $USE_UBUNTU { sudo apt install musl-tools -y }
-            cargo-build-nu
+            cargo-build-nu $flags
         }
     }
 }
@@ -97,7 +116,7 @@ if $os in ['macos-latest'] or $USE_UBUNTU {
 # Build for Windows without static-link-openssl feature
 # ----------------------------------------------------------------------------
 if $os in ['windows-latest'] {
-    cargo-build-nu
+    cargo-build-nu $flags
 }
 
 # ----------------------------------------------------------------------------
@@ -115,15 +134,9 @@ print $'(char nl)All executable files:'; hr-line
 print (ls -f ($executable | into glob)); sleep 1sec
 
 print $'(char nl)Copying release files...'; hr-line
-"To use the included Nushell plugins, register the binaries with the `plugin add` command to tell Nu where to find the plugin.
+"To use Nu plugins, use the register command to tell Nu where to find the plugin. For example:
-Then you can use `plugin use` to load the plugin into your session.
-For example:
 
-> plugin add ./nu_plugin_query
+> register ./nu_plugin_query" | save $'($dist)/README.txt' -f
-> plugin use query
-
-For more information, refer to https://www.nushell.sh/book/plugins.html
-" | save $'($dist)/README.txt' -f
 [LICENSE ...(glob $executable)] | each {|it| cp -rv $it $dist } | flatten
 
 print $'(char nl)Check binary release version detail:'; hr-line
@@ -143,7 +156,7 @@ cd $dist; print $'(char nl)Creating release archive...'; hr-line
 if $os in ['macos-latest'] or $USE_UBUNTU {
 
     let files = (ls | get name)
-    let dest = $'($bin)-($version)-($target)'
+    let dest = if $env.RELEASE_TYPE == 'full' { $'($bin)-($version)-($FULL_NAME)' } else { $'($bin)-($version)-($target)' }
     let archive = $'($dist)/($dest).tar.gz'
 
     mkdir $dest
@@ -158,7 +171,7 @@ if $os in ['macos-latest'] or $USE_UBUNTU {
 
 } else if $os == 'windows-latest' {
 
-    let releaseStem = $'($bin)-($version)-($target)'
+    let releaseStem = if $env.RELEASE_TYPE == 'full' { $'($bin)-($version)-($FULL_NAME)' } else { $'($bin)-($version)-($target)' }
 
     print $'(char nl)Download less related stuffs...'; hr-line
     aria2c https://github.com/jftuga/less-Windows/releases/download/less-v608/less.exe -o less.exe
@@ -173,7 +186,7 @@ if $os in ['macos-latest'] or $USE_UBUNTU {
         # Wix need the binaries be stored in target/release/
         cp -r ($'($dist)/*' | into glob) target/release/
         ls target/release/* | print
-        cargo install cargo-wix --version 0.3.8
+        cargo install cargo-wix --version 0.3.4
         cargo wix --no-build --nocapture --package nu --output $wixRelease
         # Workaround for https://github.com/softprops/action-gh-release/issues/280
         let archive = ($wixRelease | str replace --all '\' '/')
@@ -195,11 +208,19 @@ if $os in ['macos-latest'] or $USE_UBUNTU {
     }
 }
 
-def 'cargo-build-nu' [] {
+def 'cargo-build-nu' [ options: string ] {
-    if $os == 'windows-latest' {
+    if ($options | str trim | is-empty) {
-        cargo build --release --all --target $target
+        if $os == 'windows-latest' {
+            cargo build --release --all --target $target
+        } else {
+            cargo build --release --all --target $target --features=static-link-openssl
+        }
     } else {
-        cargo build --release --all --target $target --features=static-link-openssl
+        if $os == 'windows-latest' {
+            cargo build --release --all --target $target $options
+        } else {
+            cargo build --release --all --target $target --features=static-link-openssl $options
+        }
     }
 }
 

.github/workflows/release.yml

@@ -34,35 +34,46 @@ jobs:
         include:
         - target: aarch64-apple-darwin
           os: macos-latest
+          target_rustflags: ''
         - target: x86_64-apple-darwin
           os: macos-latest
+          target_rustflags: ''
         - target: x86_64-pc-windows-msvc
           extra: 'bin'
           os: windows-latest
+          target_rustflags: ''
         - target: x86_64-pc-windows-msvc
           extra: msi
           os: windows-latest
+          target_rustflags: ''
         - target: aarch64-pc-windows-msvc
           extra: 'bin'
           os: windows-latest
+          target_rustflags: ''
         - target: aarch64-pc-windows-msvc
           extra: msi
           os: windows-latest
+          target_rustflags: ''
         - target: x86_64-unknown-linux-gnu
           os: ubuntu-20.04
+          target_rustflags: ''
         - target: x86_64-unknown-linux-musl
           os: ubuntu-20.04
+          target_rustflags: ''
         - target: aarch64-unknown-linux-gnu
           os: ubuntu-20.04
+          target_rustflags: ''
         - target: armv7-unknown-linux-gnueabihf
           os: ubuntu-20.04
+          target_rustflags: ''
         - target: riscv64gc-unknown-linux-gnu
           os: ubuntu-latest
+          target_rustflags: ''
 
     runs-on: ${{matrix.os}}
 
     steps:
-    - uses: actions/checkout@v4.1.6
+    - uses: actions/checkout@v4.1.2
 
     - name: Update Rust Toolchain Target
       run: |
@@ -70,28 +81,120 @@ jobs:
 
     - name: Setup Rust toolchain
       uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
-      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec: Error 0xc0000135`
+      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec:  Error 0xc0000135`
       with:
         cache: false
         rustflags: ''
 
     - name: Setup Nushell
-      uses: hustcer/setup-nu@v3.10
+      uses: hustcer/setup-nu@v3.9
       with:
-        version: 0.93.0
+        version: 0.91.0
 
     - name: Release Nu Binary
       id: nu
       run: nu .github/workflows/release-pkg.nu
       env:
+        RELEASE_TYPE: standard
         OS: ${{ matrix.os }}
         REF: ${{ github.ref }}
         TARGET: ${{ matrix.target }}
         _EXTRA_: ${{ matrix.extra }}
+        TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
 
     # REF: https://github.com/marketplace/actions/gh-release
     - name: Publish Archive
-      uses: softprops/action-gh-release@v2.0.5
+      uses: softprops/action-gh-release@v2.0.4
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
+      with:
+        draft: true
+        files: ${{ steps.nu.outputs.archive }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  full:
+    name: Full
+
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+        - aarch64-apple-darwin
+        - x86_64-apple-darwin
+        - x86_64-pc-windows-msvc
+        - aarch64-pc-windows-msvc
+        - x86_64-unknown-linux-gnu
+        - x86_64-unknown-linux-musl
+        - aarch64-unknown-linux-gnu
+        extra: ['bin']
+        include:
+        - target: aarch64-apple-darwin
+          os: macos-latest
+          target_rustflags: '--features=dataframe'
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: '--features=dataframe'
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe'
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe'
+        - target: aarch64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe'
+        - target: aarch64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe'
+        - target: x86_64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe'
+        - target: x86_64-unknown-linux-musl
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe'
+        - target: aarch64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe'
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+    - uses: actions/checkout@v4.1.2
+
+    - name: Update Rust Toolchain Target
+      run: |
+        echo "targets = ['${{matrix.target}}']" >> rust-toolchain.toml
+
+    - name: Setup Rust toolchain
+      uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
+      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec:  Error 0xc0000135`
+      with:
+        cache: false
+        rustflags: ''
+
+    - name: Setup Nushell
+      uses: hustcer/setup-nu@v3.9
+      with:
+        version: 0.91.0
+
+    - name: Release Nu Binary
+      id: nu
+      run: nu .github/workflows/release-pkg.nu
+      env:
+        RELEASE_TYPE: full
+        OS: ${{ matrix.os }}
+        REF: ${{ github.ref }}
+        TARGET: ${{ matrix.target }}
+        _EXTRA_: ${{ matrix.extra }}
+        TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
+
+    # REF: https://github.com/marketplace/actions/gh-release
+    - name: Publish Archive
+      uses: softprops/action-gh-release@v2.0.4
       if: ${{ startsWith(github.ref, 'refs/tags/') }}
       with:
         draft: true

.github/workflows/typos.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Actions Repository
-        uses: actions/checkout@v4.1.6
+        uses: actions/checkout@v4.1.2
 
       - name: Check spelling
-        uses: crate-ci/typos@v1.21.0
+        uses: crate-ci/typos@v1.20.3

CONTRIBUTING.md

@@ -55,6 +55,7 @@ It is good practice to cover your changes with a test. Also, try to think about
 
 Tests can be found in different places:
 * `/tests`
+* `src/tests`
 * command examples
 * crate-specific tests
 
@@ -71,6 +72,11 @@ Read cargo's documentation for more details: https://doc.rust-lang.org/cargo/ref
   cargo run
   ```
 
+- Build and run with dataframe support.
+  ```nushell
+  cargo run --features=dataframe
+  ```
+
 - Run Clippy on Nushell:
 
   ```nushell
@@ -88,6 +94,11 @@ Read cargo's documentation for more details: https://doc.rust-lang.org/cargo/ref
   cargo test --workspace
   ```
 
+  along with dataframe tests
+
+  ```nushell
+  cargo test --workspace --features=dataframe
+  ```
   or via the `toolkit.nu` command:
   ```nushell
   use toolkit.nu test
@@ -230,7 +241,7 @@ You can help us to make the review process a smooth experience:
     - Choose what simplifies having confidence in the conflict resolution and the review. **Merge commits in your branch are OK** in the squash model.
   - Feel free to notify your reviewers or affected PR authors if your change might cause larger conflicts with another change.
   - During the rollup of multiple PRs, we may choose to resolve merge conflicts and CI failures ourselves. (Allow maintainers to push to your branch to enable us to do this quickly.)
-
+ 
 ## License
 
 We use the [MIT License](https://github.com/nushell/nushell/blob/main/LICENSE) in all of our Nushell projects. If you are including or referencing a crate that uses the [GPL License](https://www.gnu.org/licenses/gpl-3.0.en.html#license-text) unfortunately we will not be able to accept your PR.

Cargo.toml

@@ -11,7 +11,7 @@ license = "MIT"
 name = "nu"
 repository = "https://github.com/nushell/nushell"
 rust-version = "1.77.2"
-version = "0.94.2"
+version = "0.92.2"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -31,7 +31,7 @@ members = [
   "crates/nu-cmd-base",
   "crates/nu-cmd-extra",
   "crates/nu-cmd-lang",
-  "crates/nu-cmd-plugin",
+  "crates/nu-cmd-dataframe",
   "crates/nu-command",
   "crates/nu-color-config",
   "crates/nu-explore",
@@ -40,9 +40,6 @@ members = [
   "crates/nu-pretty-hex",
   "crates/nu-protocol",
   "crates/nu-plugin",
-  "crates/nu-plugin-core",
-  "crates/nu-plugin-engine",
-  "crates/nu-plugin-protocol",
   "crates/nu-plugin-test-support",
   "crates/nu_plugin_inc",
   "crates/nu_plugin_gstat",
@@ -50,28 +47,23 @@ members = [
   "crates/nu_plugin_query",
   "crates/nu_plugin_custom_values",
   "crates/nu_plugin_formats",
-  "crates/nu_plugin_polars",
-  "crates/nu_plugin_stress_internals",
   "crates/nu-std",
   "crates/nu-table",
   "crates/nu-term-grid",
   "crates/nu-test-support",
   "crates/nu-utils",
-  "crates/nuon",
 ]
 
 [workspace.dependencies]
 alphanumeric-sort = "1.5"
 ansi-str = "0.8"
-anyhow = "1.0.82"
+base64 = "0.22"
-base64 = "0.22.1"
 bracoxide = "0.1.2"
-brotli = "5.0"
 byteorder = "1.5"
 bytesize = "1.3"
 calamine = "0.24.0"
 chardetng = "0.1.17"
-chrono = { default-features = false, version = "0.4.34" }
+chrono = { default-features = false, version = "0.4" }
 chrono-humanize = "0.2.3"
 chrono-tz = "0.8"
 crossbeam-channel = "0.5.8"
@@ -93,7 +85,6 @@ heck = "0.5.0"
 human-date-parser = "0.1.1"
 indexmap = "2.2"
 indicatif = "0.17"
-interprocess = "2.1.0"
 is_executable = "1.0"
 itertools = "0.12"
 libc = "0.2"
@@ -104,7 +95,7 @@ lscolors = { version = "0.17", default-features = false }
 lsp-server = "0.7.5"
 lsp-types = "0.95.0"
 mach2 = "0.4"
-md5 = { version = "0.10", package = "md-5" }
+md5 = { version = "0.10", package = "md-5"}
 miette = "7.2"
 mime = "0.3"
 mime_guess = "2.0"
@@ -118,10 +109,9 @@ num-traits = "0.2"
 omnipath = "0.1"
 once_cell = "1.18"
 open = "5.1"
-os_pipe = { version = "1.1", features = ["io_safety"] }
+os_pipe = "1.1"
 pathdiff = "0.2"
 percent-encoding = "2"
-pretty_assertions = "1.4"
 print-positions = "0.6"
 procfs = "0.16.0"
 pwd = "1.3"
@@ -131,15 +121,13 @@ quickcheck_macros = "1.0"
 rand = "0.8"
 ratatui = "0.26"
 rayon = "1.10"
-reedline = "0.32.0"
+reedline = "0.31.0"
 regex = "1.9.5"
-rmp = "0.8"
-rmp-serde = "1.3"
 ropey = "1.6.1"
 roxmltree = "0.19"
 rstest = { version = "0.18", default-features = false }
 rusqlite = "0.31"
-rust-embed = "8.4.0"
+rust-embed = "8.2.0"
 same-file = "1.0"
 serde = { version = "1.0", default-features = false }
 serde_json = "1.0"
@@ -174,22 +162,24 @@ windows = "0.54"
 winreg = "0.52"
 
 [dependencies]
-nu-cli = { path = "./crates/nu-cli", version = "0.94.2" }
+nu-cli = { path = "./crates/nu-cli", version = "0.92.2" }
-nu-cmd-base = { path = "./crates/nu-cmd-base", version = "0.94.2" }
+nu-cmd-base = { path = "./crates/nu-cmd-base", version = "0.92.2" }
-nu-cmd-lang = { path = "./crates/nu-cmd-lang", version = "0.94.2" }
+nu-cmd-lang = { path = "./crates/nu-cmd-lang", version = "0.92.2" }
-nu-cmd-plugin = { path = "./crates/nu-cmd-plugin", version = "0.94.2", optional = true }
+nu-cmd-dataframe = { path = "./crates/nu-cmd-dataframe", version = "0.92.2", features = [
-nu-cmd-extra = { path = "./crates/nu-cmd-extra", version = "0.94.2" }
+  "dataframe",
-nu-command = { path = "./crates/nu-command", version = "0.94.2" }
+], optional = true }
-nu-engine = { path = "./crates/nu-engine", version = "0.94.2" }
+nu-cmd-extra = { path = "./crates/nu-cmd-extra", version = "0.92.2" }
-nu-explore = { path = "./crates/nu-explore", version = "0.94.2" }
+nu-command = { path = "./crates/nu-command", version = "0.92.2" }
-nu-lsp = { path = "./crates/nu-lsp/", version = "0.94.2" }
+nu-engine = { path = "./crates/nu-engine", version = "0.92.2" }
-nu-parser = { path = "./crates/nu-parser", version = "0.94.2" }
+nu-explore = { path = "./crates/nu-explore", version = "0.92.2" }
-nu-path = { path = "./crates/nu-path", version = "0.94.2" }
+nu-lsp = { path = "./crates/nu-lsp/", version = "0.92.2" }
-nu-plugin-engine = { path = "./crates/nu-plugin-engine", optional = true, version = "0.94.2" }
+nu-parser = { path = "./crates/nu-parser", version = "0.92.2" }
-nu-protocol = { path = "./crates/nu-protocol", version = "0.94.2" }
+nu-path = { path = "./crates/nu-path", version = "0.92.2" }
-nu-std = { path = "./crates/nu-std", version = "0.94.2" }
+nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.92.2" }
-nu-system = { path = "./crates/nu-system", version = "0.94.2" }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.92.2" }
-nu-utils = { path = "./crates/nu-utils", version = "0.94.2" }
+nu-std = { path = "./crates/nu-std", version = "0.92.2" }
+nu-system = { path = "./crates/nu-system", version = "0.92.2" }
+nu-utils = { path = "./crates/nu-utils", version = "0.92.2" }
 
 reedline = { workspace = true, features = ["bashisms", "sqlite"] }
 
@@ -197,7 +187,7 @@ crossterm = { workspace = true }
 ctrlc = { workspace = true }
 log = { workspace = true }
 miette = { workspace = true, features = ["fancy-no-backtrace", "fancy"] }
-mimalloc = { version = "0.1.42", default-features = false, optional = true }
+mimalloc = { version = "0.1.37", default-features = false, optional = true }
 serde_json = { workspace = true }
 simplelog = "0.12"
 time = "0.3"
@@ -218,21 +208,18 @@ nix = { workspace = true, default-features = false, features = [
 ] }
 
 [dev-dependencies]
-nu-test-support = { path = "./crates/nu-test-support", version = "0.94.2" }
+nu-test-support = { path = "./crates/nu-test-support", version = "0.92.2" }
-nu-plugin-protocol = { path = "./crates/nu-plugin-protocol", version = "0.94.2" }
-nu-plugin-core = { path = "./crates/nu-plugin-core", version = "0.94.2" }
 assert_cmd = "2.0"
 dirs-next = { workspace = true }
-tango-bench = "0.5"
+divan = "0.1.14"
-pretty_assertions = { workspace = true }
+pretty_assertions = "1.4"
 rstest = { workspace = true, default-features = false }
-serial_test = "3.1"
+serial_test = "3.0"
 tempfile = { workspace = true }
 
 [features]
 plugin = [
-  "nu-plugin-engine",
+  "nu-plugin",
-  "nu-cmd-plugin",
   "nu-cli/plugin",
   "nu-parser/plugin",
   "nu-command/plugin",
@@ -250,6 +237,7 @@ default-no-clipboard = [
   "mimalloc",
 ]
 stable = ["default"]
+wasi = ["nu-cmd-lang/wasi"]
 # NOTE: individual features are also passed to `nu-cmd-lang` that uses them to generate the feature matrix in the `version` command
 
 # Enable to statically link OpenSSL (perl is required, to build OpenSSL https://docs.rs/openssl/latest/openssl/);
@@ -257,16 +245,15 @@ stable = ["default"]
 static-link-openssl = ["dep:openssl", "nu-cmd-lang/static-link-openssl"]
 
 mimalloc = ["nu-cmd-lang/mimalloc", "dep:mimalloc"]
-system-clipboard = [
+system-clipboard = ["reedline/system_clipboard", "nu-cli/system-clipboard"]
-  "reedline/system_clipboard",
-  "nu-cli/system-clipboard",
-  "nu-cmd-lang/system-clipboard",
-]
 
 # Stable (Default)
 which-support = ["nu-command/which-support", "nu-cmd-lang/which-support"]
 trash-support = ["nu-command/trash-support", "nu-cmd-lang/trash-support"]
 
+# Dataframe feature for nushell
+dataframe = ["dep:nu-cmd-dataframe", "nu-cmd-lang/dataframe"]
+
 # SQLite commands for nushell
 sqlite = ["nu-command/sqlite", "nu-cmd-lang/sqlite"]
 
@@ -305,4 +292,4 @@ bench = false
 # Run individual benchmarks like `cargo bench -- <regex>` e.g. `cargo bench -- parse`
 [[bench]]
 name = "benchmarks"
-harness = false
+harness = false

benches/benchmarks.rs

@@ -1,39 +1,95 @@
 use nu_cli::{eval_source, evaluate_commands};
-use nu_plugin_core::{Encoder, EncodingType};
+use nu_parser::parse;
-use nu_plugin_protocol::{PluginCallResponse, PluginOutput};
+use nu_plugin::{Encoder, EncodingType, PluginCallResponse, PluginOutput};
-
 use nu_protocol::{
     engine::{EngineState, Stack},
-    PipelineData, Span, Spanned, Value,
+    eval_const::create_nu_constant,
+    PipelineData, Span, Spanned, Value, NU_VARIABLE_ID,
 };
 use nu_std::load_standard_library;
 use nu_utils::{get_default_config, get_default_env};
-use std::rc::Rc;
+use std::path::{Path, PathBuf};
 
-use std::hint::black_box;
+fn main() {
-
+    // Run registered benchmarks.
-use tango_bench::{benchmark_fn, tango_benchmarks, tango_main, IntoBenchmarks};
+    divan::main();
+}
 
 fn load_bench_commands() -> EngineState {
     nu_command::add_shell_command_context(nu_cmd_lang::create_default_context())
 }
 
+fn canonicalize_path(engine_state: &EngineState, path: &Path) -> PathBuf {
+    let cwd = engine_state.current_work_dir();
+
+    if path.exists() {
+        match nu_path::canonicalize_with(path, cwd) {
+            Ok(canon_path) => canon_path,
+            Err(_) => path.to_owned(),
+        }
+    } else {
+        path.to_owned()
+    }
+}
+
+fn get_home_path(engine_state: &EngineState) -> PathBuf {
+    nu_path::home_dir()
+        .map(|path| canonicalize_path(engine_state, &path))
+        .unwrap_or_default()
+}
+
 fn setup_engine() -> EngineState {
     let mut engine_state = load_bench_commands();
-    let cwd = std::env::current_dir()
+    let home_path = get_home_path(&engine_state);
-        .unwrap()
-        .into_os_string()
-        .into_string()
-        .unwrap();
 
     // parsing config.nu breaks without PWD set, so set a valid path
-    engine_state.add_env_var("PWD".into(), Value::string(cwd, Span::test_data()));
+    engine_state.add_env_var(
+        "PWD".into(),
+        Value::string(home_path.to_string_lossy(), Span::test_data()),
+    );
 
-    engine_state.generate_nu_constant();
+    let nu_const = create_nu_constant(&engine_state, Span::unknown())
+        .expect("Failed to create nushell constant.");
+    engine_state.set_variable_const_val(NU_VARIABLE_ID, nu_const);
 
     engine_state
 }
 
+fn bench_command(bencher: divan::Bencher, scaled_command: String) {
+    bench_command_with_custom_stack_and_engine(
+        bencher,
+        scaled_command,
+        Stack::new(),
+        setup_engine(),
+    )
+}
+
+fn bench_command_with_custom_stack_and_engine(
+    bencher: divan::Bencher,
+    scaled_command: String,
+    stack: nu_protocol::engine::Stack,
+    mut engine: EngineState,
+) {
+    load_standard_library(&mut engine).unwrap();
+    let commands = Spanned {
+        span: Span::unknown(),
+        item: scaled_command,
+    };
+
+    bencher
+        .with_inputs(|| engine.clone())
+        .bench_values(|mut engine| {
+            evaluate_commands(
+                &commands,
+                &mut engine,
+                &mut stack.clone(),
+                PipelineData::empty(),
+                None,
+            )
+            .unwrap();
+        })
+}
+
 fn setup_stack_and_engine_from_command(command: &str) -> (Stack, EngineState) {
     let mut engine = setup_engine();
     let commands = Spanned {
@@ -48,13 +104,266 @@ fn setup_stack_and_engine_from_command(command: &str) -> (Stack, EngineState) {
         &mut stack,
         PipelineData::empty(),
         None,
-        false,
     )
     .unwrap();
 
     (stack, engine)
 }
 
+// FIXME: All benchmarks live in this 1 file to speed up build times when benchmarking.
+// When the *_benchmarks functions were in different files, `cargo bench` would build
+// an executable for every single one - incredibly slowly. Would be nice to figure out
+// a way to split things up again.
+
+#[divan::bench]
+fn load_standard_lib(bencher: divan::Bencher) {
+    let engine = setup_engine();
+    bencher
+        .with_inputs(|| engine.clone())
+        .bench_values(|mut engine| {
+            load_standard_library(&mut engine).unwrap();
+        })
+}
+
+#[divan::bench_group]
+mod record {
+
+    use super::*;
+
+    fn create_flat_record_string(n: i32) -> String {
+        let mut s = String::from("let record = {");
+        for i in 0..n {
+            s.push_str(&format!("col_{}: {}", i, i));
+            if i < n - 1 {
+                s.push_str(", ");
+            }
+        }
+        s.push('}');
+        s
+    }
+
+    fn create_nested_record_string(depth: i32) -> String {
+        let mut s = String::from("let record = {");
+        for _ in 0..depth {
+            s.push_str("col: {");
+        }
+        s.push_str("col_final: 0");
+        for _ in 0..depth {
+            s.push('}');
+        }
+        s.push('}');
+        s
+    }
+
+    #[divan::bench(args = [1, 10, 100, 1000])]
+    fn create(bencher: divan::Bencher, n: i32) {
+        bench_command(bencher, create_flat_record_string(n));
+    }
+
+    #[divan::bench(args = [1, 10, 100, 1000])]
+    fn flat_access(bencher: divan::Bencher, n: i32) {
+        let (stack, engine) = setup_stack_and_engine_from_command(&create_flat_record_string(n));
+        bench_command_with_custom_stack_and_engine(
+            bencher,
+            "$record.col_0 | ignore".to_string(),
+            stack,
+            engine,
+        );
+    }
+
+    #[divan::bench(args = [1, 2, 4, 8, 16, 32, 64, 128])]
+    fn nest_access(bencher: divan::Bencher, depth: i32) {
+        let (stack, engine) =
+            setup_stack_and_engine_from_command(&create_nested_record_string(depth));
+        let nested_access = ".col".repeat(depth as usize);
+        bench_command_with_custom_stack_and_engine(
+            bencher,
+            format!("$record{} | ignore", nested_access),
+            stack,
+            engine,
+        );
+    }
+}
+
+#[divan::bench_group]
+mod table {
+
+    use super::*;
+
+    fn create_example_table_nrows(n: i32) -> String {
+        let mut s = String::from("let table = [[foo bar baz]; ");
+        for i in 0..n {
+            s.push_str(&format!("[0, 1, {i}]"));
+            if i < n - 1 {
+                s.push_str(", ");
+            }
+        }
+        s.push(']');
+        s
+    }
+
+    #[divan::bench(args = [1, 10, 100, 1000])]
+    fn create(bencher: divan::Bencher, n: i32) {
+        bench_command(bencher, create_example_table_nrows(n));
+    }
+
+    #[divan::bench(args = [1, 10, 100, 1000])]
+    fn get(bencher: divan::Bencher, n: i32) {
+        let (stack, engine) = setup_stack_and_engine_from_command(&create_example_table_nrows(n));
+        bench_command_with_custom_stack_and_engine(
+            bencher,
+            "$table | get bar | math sum | ignore".to_string(),
+            stack,
+            engine,
+        );
+    }
+
+    #[divan::bench(args = [1, 10, 100, 1000])]
+    fn select(bencher: divan::Bencher, n: i32) {
+        let (stack, engine) = setup_stack_and_engine_from_command(&create_example_table_nrows(n));
+        bench_command_with_custom_stack_and_engine(
+            bencher,
+            "$table | select foo baz | ignore".to_string(),
+            stack,
+            engine,
+        );
+    }
+}
+
+#[divan::bench_group]
+mod eval_commands {
+    use super::*;
+
+    #[divan::bench(args = [100, 1_000, 10_000])]
+    fn interleave(bencher: divan::Bencher, n: i32) {
+        bench_command(
+            bencher,
+            format!("seq 1 {n} | wrap a | interleave {{ seq 1 {n} | wrap b }} | ignore"),
+        )
+    }
+
+    #[divan::bench(args = [100, 1_000, 10_000])]
+    fn interleave_with_ctrlc(bencher: divan::Bencher, n: i32) {
+        let mut engine = setup_engine();
+        engine.ctrlc = Some(std::sync::Arc::new(std::sync::atomic::AtomicBool::new(
+            false,
+        )));
+        load_standard_library(&mut engine).unwrap();
+        let commands = Spanned {
+            span: Span::unknown(),
+            item: format!("seq 1 {n} | wrap a | interleave {{ seq 1 {n} | wrap b }} | ignore"),
+        };
+
+        bencher
+            .with_inputs(|| engine.clone())
+            .bench_values(|mut engine| {
+                evaluate_commands(
+                    &commands,
+                    &mut engine,
+                    &mut nu_protocol::engine::Stack::new(),
+                    PipelineData::empty(),
+                    None,
+                )
+                .unwrap();
+            })
+    }
+
+    #[divan::bench(args = [1, 5, 10, 100, 1_000])]
+    fn for_range(bencher: divan::Bencher, n: i32) {
+        bench_command(bencher, format!("(for $x in (1..{}) {{ sleep 50ns }})", n))
+    }
+
+    #[divan::bench(args = [1, 5, 10, 100, 1_000])]
+    fn each(bencher: divan::Bencher, n: i32) {
+        bench_command(
+            bencher,
+            format!("(1..{}) | each {{|_| sleep 50ns }} | ignore", n),
+        )
+    }
+
+    #[divan::bench(args = [1, 5, 10, 100, 1_000])]
+    fn par_each_1t(bencher: divan::Bencher, n: i32) {
+        bench_command(
+            bencher,
+            format!("(1..{}) | par-each -t 1 {{|_| sleep 50ns }} | ignore", n),
+        )
+    }
+
+    #[divan::bench(args = [1, 5, 10, 100, 1_000])]
+    fn par_each_2t(bencher: divan::Bencher, n: i32) {
+        bench_command(
+            bencher,
+            format!("(1..{}) | par-each -t 2 {{|_| sleep 50ns }} | ignore", n),
+        )
+    }
+}
+
+#[divan::bench_group()]
+mod parser_benchmarks {
+    use super::*;
+
+    #[divan::bench()]
+    fn parse_default_config_file(bencher: divan::Bencher) {
+        let engine_state = setup_engine();
+        let default_env = get_default_config().as_bytes();
+
+        bencher
+            .with_inputs(|| nu_protocol::engine::StateWorkingSet::new(&engine_state))
+            .bench_refs(|working_set| parse(working_set, None, default_env, false))
+    }
+
+    #[divan::bench()]
+    fn parse_default_env_file(bencher: divan::Bencher) {
+        let engine_state = setup_engine();
+        let default_env = get_default_env().as_bytes();
+
+        bencher
+            .with_inputs(|| nu_protocol::engine::StateWorkingSet::new(&engine_state))
+            .bench_refs(|working_set| parse(working_set, None, default_env, false))
+    }
+}
+
+#[divan::bench_group()]
+mod eval_benchmarks {
+    use super::*;
+
+    #[divan::bench()]
+    fn eval_default_env(bencher: divan::Bencher) {
+        let default_env = get_default_env().as_bytes();
+        let fname = "default_env.nu";
+        bencher
+            .with_inputs(|| (setup_engine(), nu_protocol::engine::Stack::new()))
+            .bench_values(|(mut engine_state, mut stack)| {
+                eval_source(
+                    &mut engine_state,
+                    &mut stack,
+                    default_env,
+                    fname,
+                    PipelineData::empty(),
+                    false,
+                )
+            })
+    }
+
+    #[divan::bench()]
+    fn eval_default_config(bencher: divan::Bencher) {
+        let default_env = get_default_config().as_bytes();
+        let fname = "default_config.nu";
+        bencher
+            .with_inputs(|| (setup_engine(), nu_protocol::engine::Stack::new()))
+            .bench_values(|(mut engine_state, mut stack)| {
+                eval_source(
+                    &mut engine_state,
+                    &mut stack,
+                    default_env,
+                    fname,
+                    PipelineData::empty(),
+                    false,
+                )
+            })
+    }
+}
+
 // generate a new table data with `row_cnt` rows, `col_cnt` columns.
 fn encoding_test_data(row_cnt: usize, col_cnt: usize) -> Value {
     let record = Value::test_record(
@@ -66,424 +375,76 @@ fn encoding_test_data(row_cnt: usize, col_cnt: usize) -> Value {
     Value::list(vec![record; row_cnt], Span::test_data())
 }
 
-fn bench_command(
+#[divan::bench_group()]
-    name: &str,
+mod encoding_benchmarks {
-    command: &str,
+    use super::*;
-    stack: Stack,
-    engine: EngineState,
-) -> impl IntoBenchmarks {
-    let commands = Spanned {
-        span: Span::unknown(),
-        item: command.to_string(),
-    };
-    [benchmark_fn(name, move |b| {
-        let commands = commands.clone();
-        let stack = stack.clone();
-        let engine = engine.clone();
-        b.iter(move || {
-            let mut stack = stack.clone();
-            let mut engine = engine.clone();
-            #[allow(clippy::unit_arg)]
-            black_box(
-                evaluate_commands(
-                    &commands,
-                    &mut engine,
-                    &mut stack,
-                    PipelineData::empty(),
-                    None,
-                    false,
-                )
-                .unwrap(),
-            );
-        })
-    })]
-}
 
-fn bench_eval_source(
+    #[divan::bench(args = [(100, 5), (10000, 15)])]
-    name: &str,
+    fn json_encode(bencher: divan::Bencher, (row_cnt, col_cnt): (usize, usize)) {
-    fname: String,
+        let test_data = PluginOutput::CallResponse(
-    source: Vec<u8>,
+            0,
-    stack: Stack,
+            PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
-    engine: EngineState,
+        );
-) -> impl IntoBenchmarks {
+        let encoder = EncodingType::try_from_bytes(b"json").unwrap();
-    [benchmark_fn(name, move |b| {
+        bencher
-        let stack = stack.clone();
+            .with_inputs(Vec::new)
-        let engine = engine.clone();
+            .bench_values(|mut res| encoder.encode(&test_data, &mut res))
-        let fname = fname.clone();
-        let source = source.clone();
-        b.iter(move || {
-            let mut stack = stack.clone();
-            let mut engine = engine.clone();
-            let fname: &str = &fname.clone();
-            let source: &[u8] = &source.clone();
-            black_box(eval_source(
-                &mut engine,
-                &mut stack,
-                source,
-                fname,
-                PipelineData::empty(),
-                false,
-            ));
-        })
-    })]
-}
-
-/// Load the standard library into the engine.
-fn bench_load_standard_lib() -> impl IntoBenchmarks {
-    [benchmark_fn("load_standard_lib", move |b| {
-        let engine = setup_engine();
-        b.iter(move || {
-            let mut engine = engine.clone();
-            load_standard_library(&mut engine)
-        })
-    })]
-}
-
-fn create_flat_record_string(n: i32) -> String {
-    let mut s = String::from("let record = {");
-    for i in 0..n {
-        s.push_str(&format!("col_{}: {}", i, i));
-        if i < n - 1 {
-            s.push_str(", ");
-        }
     }
-    s.push('}');
-    s
-}
 
-fn create_nested_record_string(depth: i32) -> String {
+    #[divan::bench(args = [(100, 5), (10000, 15)])]
-    let mut s = String::from("let record = {");
+    fn msgpack_encode(bencher: divan::Bencher, (row_cnt, col_cnt): (usize, usize)) {
-    for _ in 0..depth {
+        let test_data = PluginOutput::CallResponse(
-        s.push_str("col: {");
+            0,
+            PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
+        );
+        let encoder = EncodingType::try_from_bytes(b"msgpack").unwrap();
+        bencher
+            .with_inputs(Vec::new)
+            .bench_values(|mut res| encoder.encode(&test_data, &mut res))
     }
-    s.push_str("col_final: 0");
-    for _ in 0..depth {
-        s.push('}');
-    }
-    s.push('}');
-    s
 }
 
-fn create_example_table_nrows(n: i32) -> String {
+#[divan::bench_group()]
-    let mut s = String::from("let table = [[foo bar baz]; ");
+mod decoding_benchmarks {
-    for i in 0..n {
+    use super::*;
-        s.push_str(&format!("[0, 1, {i}]"));
-        if i < n - 1 {
-            s.push_str(", ");
-        }
-    }
-    s.push(']');
-    s
-}
 
-fn bench_record_create(n: i32) -> impl IntoBenchmarks {
+    #[divan::bench(args = [(100, 5), (10000, 15)])]
-    bench_command(
+    fn json_decode(bencher: divan::Bencher, (row_cnt, col_cnt): (usize, usize)) {
-        &format!("record_create_{n}"),
+        let test_data = PluginOutput::CallResponse(
-        &create_flat_record_string(n),
+            0,
-        Stack::new(),
+            PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
-        setup_engine(),
+        );
-    )
+        let encoder = EncodingType::try_from_bytes(b"json").unwrap();
-}
+        let mut res = vec![];
-
+        encoder.encode(&test_data, &mut res).unwrap();
-fn bench_record_flat_access(n: i32) -> impl IntoBenchmarks {
+        bencher
-    let setup_command = create_flat_record_string(n);
+            .with_inputs(|| {
-    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
-    bench_command(
-        &format!("record_flat_access_{n}"),
-        "$record.col_0 | ignore",
-        stack,
-        engine,
-    )
-}
-
-fn bench_record_nested_access(n: i32) -> impl IntoBenchmarks {
-    let setup_command = create_nested_record_string(n);
-    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
-    let nested_access = ".col".repeat(n as usize);
-    bench_command(
-        &format!("record_nested_access_{n}"),
-        &format!("$record{} | ignore", nested_access),
-        stack,
-        engine,
-    )
-}
-
-fn bench_table_create(n: i32) -> impl IntoBenchmarks {
-    bench_command(
-        &format!("table_create_{n}"),
-        &create_example_table_nrows(n),
-        Stack::new(),
-        setup_engine(),
-    )
-}
-
-fn bench_table_get(n: i32) -> impl IntoBenchmarks {
-    let setup_command = create_example_table_nrows(n);
-    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
-    bench_command(
-        &format!("table_get_{n}"),
-        "$table | get bar | math sum | ignore",
-        stack,
-        engine,
-    )
-}
-
-fn bench_table_select(n: i32) -> impl IntoBenchmarks {
-    let setup_command = create_example_table_nrows(n);
-    let (stack, engine) = setup_stack_and_engine_from_command(&setup_command);
-    bench_command(
-        &format!("table_select_{n}"),
-        "$table | select foo baz | ignore",
-        stack,
-        engine,
-    )
-}
-
-fn bench_eval_interleave(n: i32) -> impl IntoBenchmarks {
-    let engine = setup_engine();
-    let stack = Stack::new();
-    bench_command(
-        &format!("eval_interleave_{n}"),
-        &format!("seq 1 {n} | wrap a | interleave {{ seq 1 {n} | wrap b }} | ignore"),
-        stack,
-        engine,
-    )
-}
-
-fn bench_eval_interleave_with_ctrlc(n: i32) -> impl IntoBenchmarks {
-    let mut engine = setup_engine();
-    engine.ctrlc = Some(std::sync::Arc::new(std::sync::atomic::AtomicBool::new(
-        false,
-    )));
-    let stack = Stack::new();
-    bench_command(
-        &format!("eval_interleave_with_ctrlc_{n}"),
-        &format!("seq 1 {n} | wrap a | interleave {{ seq 1 {n} | wrap b }} | ignore"),
-        stack,
-        engine,
-    )
-}
-
-fn bench_eval_for(n: i32) -> impl IntoBenchmarks {
-    let engine = setup_engine();
-    let stack = Stack::new();
-    bench_command(
-        &format!("eval_for_{n}"),
-        &format!("(for $x in (1..{n}) {{ 1 }}) | ignore"),
-        stack,
-        engine,
-    )
-}
-
-fn bench_eval_each(n: i32) -> impl IntoBenchmarks {
-    let engine = setup_engine();
-    let stack = Stack::new();
-    bench_command(
-        &format!("eval_each_{n}"),
-        &format!("(1..{n}) | each {{|_| 1 }} | ignore"),
-        stack,
-        engine,
-    )
-}
-
-fn bench_eval_par_each(n: i32) -> impl IntoBenchmarks {
-    let engine = setup_engine();
-    let stack = Stack::new();
-    bench_command(
-        &format!("eval_par_each_{n}"),
-        &format!("(1..{}) | par-each -t 2 {{|_| 1 }} | ignore", n),
-        stack,
-        engine,
-    )
-}
-
-fn bench_eval_default_config() -> impl IntoBenchmarks {
-    let default_env = get_default_config().as_bytes().to_vec();
-    let fname = "default_config.nu".to_string();
-    bench_eval_source(
-        "eval_default_config",
-        fname,
-        default_env,
-        Stack::new(),
-        setup_engine(),
-    )
-}
-
-fn bench_eval_default_env() -> impl IntoBenchmarks {
-    let default_env = get_default_env().as_bytes().to_vec();
-    let fname = "default_env.nu".to_string();
-    bench_eval_source(
-        "eval_default_env",
-        fname,
-        default_env,
-        Stack::new(),
-        setup_engine(),
-    )
-}
-
-fn encode_json(row_cnt: usize, col_cnt: usize) -> impl IntoBenchmarks {
-    let test_data = Rc::new(PluginOutput::CallResponse(
-        0,
-        PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
-    ));
-    let encoder = Rc::new(EncodingType::try_from_bytes(b"json").unwrap());
-
-    [benchmark_fn(
-        format!("encode_json_{}_{}", row_cnt, col_cnt),
-        move |b| {
-            let encoder = encoder.clone();
-            let test_data = test_data.clone();
-            b.iter(move || {
-                let mut res = Vec::new();
-                encoder.encode(&*test_data, &mut res).unwrap();
-            })
-        },
-    )]
-}
-
-fn encode_msgpack(row_cnt: usize, col_cnt: usize) -> impl IntoBenchmarks {
-    let test_data = Rc::new(PluginOutput::CallResponse(
-        0,
-        PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
-    ));
-    let encoder = Rc::new(EncodingType::try_from_bytes(b"msgpack").unwrap());
-
-    [benchmark_fn(
-        format!("encode_msgpack_{}_{}", row_cnt, col_cnt),
-        move |b| {
-            let encoder = encoder.clone();
-            let test_data = test_data.clone();
-            b.iter(move || {
-                let mut res = Vec::new();
-                encoder.encode(&*test_data, &mut res).unwrap();
-            })
-        },
-    )]
-}
-
-fn decode_json(row_cnt: usize, col_cnt: usize) -> impl IntoBenchmarks {
-    let test_data = PluginOutput::CallResponse(
-        0,
-        PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
-    );
-    let encoder = EncodingType::try_from_bytes(b"json").unwrap();
-    let mut res = vec![];
-    encoder.encode(&test_data, &mut res).unwrap();
-
-    [benchmark_fn(
-        format!("decode_json_{}_{}", row_cnt, col_cnt),
-        move |b| {
-            let res = res.clone();
-            b.iter(move || {
                 let mut binary_data = std::io::Cursor::new(res.clone());
                 binary_data.set_position(0);
-                let _: Result<Option<PluginOutput>, _> =
+                binary_data
-                    black_box(encoder.decode(&mut binary_data));
             })
-        },
+            .bench_values(|mut binary_data| -> Result<Option<PluginOutput>, _> {
-    )]
+                encoder.decode(&mut binary_data)
-}
+            })
+    }
 
-fn decode_msgpack(row_cnt: usize, col_cnt: usize) -> impl IntoBenchmarks {
+    #[divan::bench(args = [(100, 5), (10000, 15)])]
-    let test_data = PluginOutput::CallResponse(
+    fn msgpack_decode(bencher: divan::Bencher, (row_cnt, col_cnt): (usize, usize)) {
-        0,
+        let test_data = PluginOutput::CallResponse(
-        PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
+            0,
-    );
+            PluginCallResponse::value(encoding_test_data(row_cnt, col_cnt)),
-    let encoder = EncodingType::try_from_bytes(b"msgpack").unwrap();
+        );
-    let mut res = vec![];
+        let encoder = EncodingType::try_from_bytes(b"msgpack").unwrap();
-    encoder.encode(&test_data, &mut res).unwrap();
+        let mut res = vec![];
-
+        encoder.encode(&test_data, &mut res).unwrap();
-    [benchmark_fn(
+        bencher
-        format!("decode_msgpack_{}_{}", row_cnt, col_cnt),
+            .with_inputs(|| {
-        move |b| {
-            let res = res.clone();
-            b.iter(move || {
                 let mut binary_data = std::io::Cursor::new(res.clone());
                 binary_data.set_position(0);
-                let _: Result<Option<PluginOutput>, _> =
+                binary_data
-                    black_box(encoder.decode(&mut binary_data));
             })
-        },
+            .bench_values(|mut binary_data| -> Result<Option<PluginOutput>, _> {
-    )]
+                encoder.decode(&mut binary_data)
+            })
+    }
 }
-
-tango_benchmarks!(
-    bench_load_standard_lib(),
-    // Data types
-    // Record
-    bench_record_create(1),
-    bench_record_create(10),
-    bench_record_create(100),
-    bench_record_create(1_000),
-    bench_record_flat_access(1),
-    bench_record_flat_access(10),
-    bench_record_flat_access(100),
-    bench_record_flat_access(1_000),
-    bench_record_nested_access(1),
-    bench_record_nested_access(2),
-    bench_record_nested_access(4),
-    bench_record_nested_access(8),
-    bench_record_nested_access(16),
-    bench_record_nested_access(32),
-    bench_record_nested_access(64),
-    bench_record_nested_access(128),
-    // Table
-    bench_table_create(1),
-    bench_table_create(10),
-    bench_table_create(100),
-    bench_table_create(1_000),
-    bench_table_get(1),
-    bench_table_get(10),
-    bench_table_get(100),
-    bench_table_get(1_000),
-    bench_table_select(1),
-    bench_table_select(10),
-    bench_table_select(100),
-    bench_table_select(1_000),
-    // Eval
-    // Interleave
-    bench_eval_interleave(100),
-    bench_eval_interleave(1_000),
-    bench_eval_interleave(10_000),
-    bench_eval_interleave_with_ctrlc(100),
-    bench_eval_interleave_with_ctrlc(1_000),
-    bench_eval_interleave_with_ctrlc(10_000),
-    // For
-    bench_eval_for(1),
-    bench_eval_for(10),
-    bench_eval_for(100),
-    bench_eval_for(1_000),
-    bench_eval_for(10_000),
-    // Each
-    bench_eval_each(1),
-    bench_eval_each(10),
-    bench_eval_each(100),
-    bench_eval_each(1_000),
-    bench_eval_each(10_000),
-    // Par-Each
-    bench_eval_par_each(1),
-    bench_eval_par_each(10),
-    bench_eval_par_each(100),
-    bench_eval_par_each(1_000),
-    bench_eval_par_each(10_000),
-    // Config
-    bench_eval_default_config(),
-    // Env
-    bench_eval_default_env(),
-    // Encode
-    // Json
-    encode_json(100, 5),
-    encode_json(10000, 15),
-    // MsgPack
-    encode_msgpack(100, 5),
-    encode_msgpack(10000, 15),
-    // Decode
-    // Json
-    decode_json(100, 5),
-    decode_json(10000, 15),
-    // MsgPack
-    decode_msgpack(100, 5),
-    decode_msgpack(10000, 15)
-);
-
-tango_main!();

crates/nu-cli/Cargo.toml

@@ -5,27 +5,25 @@ repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cli"
 edition = "2021"
 license = "MIT"
 name = "nu-cli"
-version = "0.94.2"
+version = "0.92.2"
 
 [lib]
 bench = false
 
 [dev-dependencies]
-nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.94.2" }
+nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.92.2" }
-nu-command = { path = "../nu-command", version = "0.94.2" }
+nu-command = { path = "../nu-command", version = "0.92.2" }
-nu-test-support = { path = "../nu-test-support", version = "0.94.2" }
+nu-test-support = { path = "../nu-test-support", version = "0.92.2" }
 rstest = { workspace = true, default-features = false }
-tempfile = { workspace = true }
 
 [dependencies]
-nu-cmd-base = { path = "../nu-cmd-base", version = "0.94.2" }
+nu-cmd-base = { path = "../nu-cmd-base", version = "0.92.2" }
-nu-engine = { path = "../nu-engine", version = "0.94.2" }
+nu-engine = { path = "../nu-engine", version = "0.92.2" }
-nu-path = { path = "../nu-path", version = "0.94.2" }
+nu-path = { path = "../nu-path", version = "0.92.2" }
-nu-parser = { path = "../nu-parser", version = "0.94.2" }
+nu-parser = { path = "../nu-parser", version = "0.92.2" }
-nu-plugin-engine = { path = "../nu-plugin-engine", version = "0.94.2", optional = true }
+nu-protocol = { path = "../nu-protocol", version = "0.92.2" }
-nu-protocol = { path = "../nu-protocol", version = "0.94.2" }
+nu-utils = { path = "../nu-utils", version = "0.92.2" }
-nu-utils = { path = "../nu-utils", version = "0.94.2" }
+nu-color-config = { path = "../nu-color-config", version = "0.92.2" }
-nu-color-config = { path = "../nu-color-config", version = "0.94.2" }
 nu-ansi-term = { workspace = true }
 reedline = { workspace = true, features = ["bashisms", "sqlite"] }
 
@@ -39,11 +37,12 @@ miette = { workspace = true, features = ["fancy-no-backtrace"] }
 lscolors = { workspace = true, default-features = false, features = ["nu-ansi-term"] }
 once_cell = { workspace = true }
 percent-encoding = { workspace = true }
+pathdiff = { workspace = true }
 sysinfo = { workspace = true }
 unicode-segmentation = { workspace = true }
 uuid = { workspace = true, features = ["v4"] }
 which = { workspace = true }
 
 [features]
-plugin = ["nu-plugin-engine"]
+plugin = []
-system-clipboard = ["reedline/system_clipboard"]
+system-clipboard = ["reedline/system_clipboard"]

crates/nu-cli/src/commands/commandline/commandline_.rs

@@ -1,4 +1,5 @@
 use nu_engine::command_prelude::*;
+use unicode_segmentation::UnicodeSegmentation;
 
 #[derive(Clone)]
 pub struct Commandline;
@@ -10,12 +11,45 @@ impl Command for Commandline {
 
     fn signature(&self) -> Signature {
         Signature::build("commandline")
-            .input_output_types(vec![(Type::Nothing, Type::String)])
+            .input_output_types(vec![
+                (Type::Nothing, Type::Nothing),
+                (Type::String, Type::String),
+            ])
+            .switch(
+                "cursor",
+                "Set or get the current cursor position",
+                Some('c'),
+            )
+            .switch(
+                "cursor-end",
+                "Set the current cursor position to the end of the buffer",
+                Some('e'),
+            )
+            .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 the current command line input buffer."
+        "View or modify the current command line input buffer."
     }
 
     fn search_terms(&self) -> Vec<&str> {
@@ -25,11 +59,126 @@ impl Command for Commandline {
     fn run(
         &self,
         engine_state: &EngineState,
-        _stack: &mut Stack,
+        stack: &mut Stack,
         call: &Call,
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let repl = engine_state.repl_state.lock().expect("repl state mutex");
+        if let Some(cmd) = call.opt::<Value>(engine_state, stack, 0)? {
-        Ok(Value::string(repl.buffer.clone(), call.head).into_pipeline_data())
+            let span = cmd.span();
+            let cmd = cmd.coerce_into_string()?;
+            let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
+
+            if call.has_flag(engine_state, stack, "cursor")? {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--cursor (-c)` is deprecated".into(),
+                        msg: "Setting the current cursor position by `--cursor (-c)` is deprecated"
+                            .into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline set-cursor`".into()),
+                        inner: vec![],
+                    },
+                );
+                match cmd.parse::<i64>() {
+                    Ok(n) => {
+                        repl.cursor_pos = if n <= 0 {
+                            0usize
+                        } else {
+                            repl.buffer
+                                .grapheme_indices(true)
+                                .map(|(i, _c)| i)
+                                .nth(n as usize)
+                                .unwrap_or(repl.buffer.len())
+                        }
+                    }
+                    Err(_) => {
+                        return Err(ShellError::CantConvert {
+                            to_type: "int".to_string(),
+                            from_type: "string".to_string(),
+                            span,
+                            help: Some(format!(r#"string "{cmd}" does not represent a valid int"#)),
+                        })
+                    }
+                }
+            } else if call.has_flag(engine_state, stack, "append")? {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--append (-a)` is deprecated".into(),
+                        msg: "Appending the string to the end of the buffer by `--append (-a)` is deprecated".into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline edit --append (-a)`".into()),
+                        inner: vec![],
+                    },
+                );
+                repl.buffer.push_str(&cmd);
+            } else if call.has_flag(engine_state, stack, "insert")? {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--insert (-i)` is deprecated".into(),
+                        msg: "Inserts the string into the buffer at the cursor position by `--insert (-i)` is deprecated".into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline edit --insert (-i)`".into()),
+                        inner: vec![],
+                    },
+                );
+                let cursor_pos = repl.cursor_pos;
+                repl.buffer.insert_str(cursor_pos, &cmd);
+                repl.cursor_pos += cmd.len();
+            } else {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--replace (-r)` is deprecated".into(),
+                        msg: "Replacing the current contents of the buffer by `--replace (-p)` or positional argument is deprecated".into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline edit --replace (-r)`".into()),
+                        inner: vec![],
+                    },
+                );
+                repl.buffer = cmd;
+                repl.cursor_pos = repl.buffer.len();
+            }
+            Ok(Value::nothing(call.head).into_pipeline_data())
+        } else {
+            let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
+            if call.has_flag(engine_state, stack, "cursor-end")? {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--cursor-end (-e)` is deprecated".into(),
+                        msg: "Setting the current cursor position to the end of the buffer by `--cursor-end (-e)` is deprecated".into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline set-cursor --end (-e)`".into()),
+                        inner: vec![],
+                    },
+                );
+                repl.cursor_pos = repl.buffer.len();
+                Ok(Value::nothing(call.head).into_pipeline_data())
+            } else if call.has_flag(engine_state, stack, "cursor")? {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--cursor (-c)` is deprecated".into(),
+                        msg: "Getting the current cursor position by `--cursor (-c)` is deprecated"
+                            .into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline get-cursor`".into()),
+                        inner: vec![],
+                    },
+                );
+                let char_pos = repl
+                    .buffer
+                    .grapheme_indices(true)
+                    .chain(std::iter::once((repl.buffer.len(), "")))
+                    .position(|(i, _c)| i == repl.cursor_pos)
+                    .expect("Cursor position isn't on a grapheme boundary");
+                Ok(Value::string(char_pos.to_string(), call.head).into_pipeline_data())
+            } else {
+                Ok(Value::string(repl.buffer.to_string(), call.head).into_pipeline_data())
+            }
+        }
     }
 }

crates/nu-cli/src/commands/history/history_.rs

@@ -107,7 +107,7 @@ impl Command for History {
                             file: history_path.display().to_string(),
                             span: head,
                         })?
-                        .into_pipeline_data(head, ctrlc)),
+                        .into_pipeline_data(ctrlc)),
                     HistoryFileFormat::Sqlite => Ok(history_reader
                         .and_then(|h| {
                             h.search(SearchQuery::everything(SearchDirection::Forward, None))
@@ -122,7 +122,7 @@ impl Command for History {
                             file: history_path.display().to_string(),
                             span: head,
                         })?
-                        .into_pipeline_data(head, ctrlc)),
+                        .into_pipeline_data(ctrlc)),
                 }
             }
         } else {

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

@@ -36,6 +36,16 @@ For more information on input and keybindings, check:
         call: &Call,
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        Ok(Value::string(get_full_help(self, engine_state, stack), call.head).into_pipeline_data())
+        Ok(Value::string(
+            get_full_help(
+                &Keybindings.signature(),
+                &Keybindings.examples(),
+                engine_state,
+                stack,
+                self.is_parser_keyword(),
+            ),
+            call.head,
+        )
+        .into_pipeline_data())
     }
 }

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

@@ -12,7 +12,7 @@ impl Command for KeybindingsDefault {
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .category(Category::Platform)
-            .input_output_types(vec![(Type::Nothing, Type::table())])
+            .input_output_types(vec![(Type::Nothing, Type::Table(vec![]))])
     }
 
     fn usage(&self) -> &str {

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

@@ -14,7 +14,7 @@ impl Command for KeybindingsList {
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
-            .input_output_types(vec![(Type::Nothing, Type::table())])
+            .input_output_types(vec![(Type::Nothing, Type::Table(vec![]))])
             .switch("modifiers", "list of modifiers", Some('m'))
             .switch("keycodes", "list of keycodes", Some('k'))
             .switch("modes", "list of edit modes", Some('o'))

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

@@ -1,18 +1,13 @@
 use crate::completions::{CompletionOptions, SortBy};
-use nu_protocol::{
+use nu_protocol::{engine::StateWorkingSet, levenshtein_distance, Span};
-    engine::{Stack, StateWorkingSet},
-    levenshtein_distance, Span,
-};
 use reedline::Suggestion;
 
 // Completer trait represents the three stages of the completion
 // fetch, filter and sort
 pub trait Completer {
-    #[allow(clippy::too_many_arguments)]
     fn fetch(
         &mut self,
         working_set: &StateWorkingSet,
-        stack: &Stack,
         prefix: Vec<u8>,
         span: Span,
         offset: usize,

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

@@ -4,14 +4,16 @@ use crate::{
 };
 use nu_parser::FlatShape;
 use nu_protocol::{
-    engine::{CachedFile, Stack, StateWorkingSet},
+    engine::{CachedFile, EngineState, StateWorkingSet},
     Span,
 };
 use reedline::Suggestion;
+use std::sync::Arc;
 
 use super::SemanticSuggestion;
 
 pub struct CommandCompletion {
+    engine_state: Arc<EngineState>,
     flattened: Vec<(Span, FlatShape)>,
     flat_shape: FlatShape,
     force_completion_after_space: bool,
@@ -19,11 +21,14 @@ pub struct CommandCompletion {
 
 impl CommandCompletion {
     pub fn new(
+        engine_state: Arc<EngineState>,
+        _: &StateWorkingSet,
         flattened: Vec<(Span, FlatShape)>,
         flat_shape: FlatShape,
         force_completion_after_space: bool,
     ) -> Self {
         Self {
+            engine_state,
             flattened,
             flat_shape,
             force_completion_after_space,
@@ -32,14 +37,13 @@ impl CommandCompletion {
 
     fn external_command_completion(
         &self,
-        working_set: &StateWorkingSet,
         prefix: &str,
         match_algorithm: MatchAlgorithm,
     ) -> Vec<String> {
         let mut executables = vec![];
 
         // os agnostic way to get the PATH env var
-        let paths = working_set.permanent_state.get_path_env_var();
+        let paths = self.engine_state.get_path_env_var();
 
         if let Some(paths) = paths {
             if let Ok(paths) = paths.as_list() {
@@ -48,10 +52,7 @@ impl CommandCompletion {
 
                     if let Ok(mut contents) = std::fs::read_dir(path.as_ref()) {
                         while let Some(Ok(item)) = contents.next() {
-                            if working_set
+                            if self.engine_state.config.max_external_completion_results
-                                .permanent_state
-                                .config
-                                .max_external_completion_results
                                 > executables.len() as i64
                                 && !executables.contains(
                                     &item
@@ -113,7 +114,7 @@ impl CommandCompletion {
 
         if find_externals {
             let results_external = self
-                .external_command_completion(working_set, &partial, match_algorithm)
+                .external_command_completion(&partial, match_algorithm)
                 .into_iter()
                 .map(move |x| SemanticSuggestion {
                     suggestion: Suggestion {
@@ -160,7 +161,6 @@ impl Completer for CommandCompletion {
     fn fetch(
         &mut self,
         working_set: &StateWorkingSet,
-        _stack: &Stack,
         _prefix: Vec<u8>,
         span: Span,
         offset: usize,
@@ -266,8 +266,6 @@ pub fn is_passthrough_command(working_set_file_contents: &[CachedFile]) -> bool
 #[cfg(test)]
 mod command_completions_tests {
     use super::*;
-    use nu_protocol::engine::EngineState;
-    use std::sync::Arc;
 
     #[test]
     fn test_find_non_whitespace_index() {

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

@@ -7,8 +7,8 @@ use nu_engine::eval_block;
 use nu_parser::{flatten_pipeline_element, parse, FlatShape};
 use nu_protocol::{
     debugger::WithoutDebug,
-    engine::{Closure, EngineState, Stack, StateWorkingSet},
+    engine::{EngineState, Stack, StateWorkingSet},
-    PipelineData, Span, Value,
+    BlockId, PipelineData, Span, Value,
 };
 use reedline::{Completer as ReedlineCompleter, Suggestion};
 use std::{str, sync::Arc};
@@ -22,10 +22,10 @@ pub struct NuCompleter {
 }
 
 impl NuCompleter {
-    pub fn new(engine_state: Arc<EngineState>, stack: Arc<Stack>) -> Self {
+    pub fn new(engine_state: Arc<EngineState>, stack: Stack) -> Self {
         Self {
             engine_state,
-            stack: Stack::with_parent(stack).reset_out_dest().capture(),
+            stack: stack.reset_stdio().capture(),
         }
     }
 
@@ -52,15 +52,8 @@ impl NuCompleter {
         };
 
         // Fetch
-        let mut suggestions = completer.fetch(
+        let mut suggestions =
-            working_set,
+            completer.fetch(working_set, prefix.clone(), new_span, offset, pos, &options);
-            &self.stack,
-            prefix.clone(),
-            new_span,
-            offset,
-            pos,
-            &options,
-        );
 
         // Sort
         suggestions = completer.sort(suggestions, prefix);
@@ -70,15 +63,15 @@ impl NuCompleter {
 
     fn external_completion(
         &self,
-        closure: &Closure,
+        block_id: BlockId,
         spans: &[String],
         offset: usize,
         span: Span,
     ) -> Option<Vec<SemanticSuggestion>> {
-        let block = self.engine_state.get_block(closure.block_id);
+        let block = self.engine_state.get_block(block_id);
         let mut callee_stack = self
             .stack
-            .captures_to_stack_preserve_out_dest(closure.captures.clone());
+            .gather_captures(&self.engine_state, &block.captures);
 
         // Line
         if let Some(pos_arg) = block.signature.required_positional.first() {
@@ -103,8 +96,9 @@ impl NuCompleter {
             PipelineData::empty(),
         );
 
-        match result.and_then(|data| data.into_value(span)) {
+        match result {
-            Ok(value) => {
+            Ok(pd) => {
+                let value = pd.into_value(span);
                 if let Value::List { vals, .. } = value {
                     let result =
                         map_value_completions(vals.iter(), Span::new(span.start, span.end), offset);
@@ -181,8 +175,11 @@ impl NuCompleter {
 
                         // Variables completion
                         if prefix.starts_with(b"$") || most_left_var.is_some() {
-                            let mut completer =
+                            let mut completer = VariableCompletion::new(
-                                VariableCompletion::new(most_left_var.unwrap_or((vec![], vec![])));
+                                self.engine_state.clone(),
+                                self.stack.clone(),
+                                most_left_var.unwrap_or((vec![], vec![])),
+                            );
 
                             return self.process_completion(
                                 &mut completer,
@@ -213,10 +210,13 @@ impl NuCompleter {
 
                             // We got no results for internal completion
                             // now we can check if external completer is set and use it
-                            if let Some(closure) = config.external_completer.as_ref() {
+                            if let Some(block_id) = config.external_completer {
-                                if let Some(external_result) =
+                                if let Some(external_result) = self.external_completion(
-                                    self.external_completion(closure, &spans, fake_offset, new_span)
+                                    block_id,
-                                {
+                                    &spans,
+                                    fake_offset,
+                                    new_span,
+                                ) {
                                     return external_result;
                                 }
                             }
@@ -227,6 +227,8 @@ impl NuCompleter {
                             || (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,
@@ -254,7 +256,10 @@ impl NuCompleter {
                                     || prev_expr_str == b"overlay use"
                                     || prev_expr_str == b"source-env"
                                 {
-                                    let mut completer = DotNuCompletion::new();
+                                    let mut completer = DotNuCompletion::new(
+                                        self.engine_state.clone(),
+                                        self.stack.clone(),
+                                    );
 
                                     return self.process_completion(
                                         &mut completer,
@@ -265,7 +270,10 @@ impl NuCompleter {
                                         pos,
                                     );
                                 } else if prev_expr_str == b"ls" {
-                                    let mut completer = FileCompletion::new();
+                                    let mut completer = FileCompletion::new(
+                                        self.engine_state.clone(),
+                                        self.stack.clone(),
+                                    );
 
                                     return self.process_completion(
                                         &mut completer,
@@ -283,6 +291,7 @@ impl NuCompleter {
                         match &flat.1 {
                             FlatShape::Custom(decl_id) => {
                                 let mut completer = CustomCompletion::new(
+                                    self.engine_state.clone(),
                                     self.stack.clone(),
                                     *decl_id,
                                     initial_line,
@@ -298,7 +307,10 @@ impl NuCompleter {
                                 );
                             }
                             FlatShape::Directory => {
-                                let mut completer = DirectoryCompletion::new();
+                                let mut completer = DirectoryCompletion::new(
+                                    self.engine_state.clone(),
+                                    self.stack.clone(),
+                                );
 
                                 return self.process_completion(
                                     &mut completer,
@@ -310,7 +322,10 @@ impl NuCompleter {
                                 );
                             }
                             FlatShape::Filepath | FlatShape::GlobPattern => {
-                                let mut completer = FileCompletion::new();
+                                let mut completer = FileCompletion::new(
+                                    self.engine_state.clone(),
+                                    self.stack.clone(),
+                                );
 
                                 return self.process_completion(
                                     &mut completer,
@@ -323,6 +338,8 @@ impl NuCompleter {
                             }
                             flat_shape => {
                                 let mut completer = CommandCompletion::new(
+                                    self.engine_state.clone(),
+                                    &working_set,
                                     flattened.clone(),
                                     // flat_idx,
                                     flat_shape.clone(),
@@ -343,9 +360,9 @@ impl NuCompleter {
                                 }
 
                                 // Try to complete using an external completer (if set)
-                                if let Some(closure) = config.external_completer.as_ref() {
+                                if let Some(block_id) = config.external_completer {
                                     if let Some(external_result) = self.external_completion(
-                                        closure,
+                                        block_id,
                                         &spans,
                                         fake_offset,
                                         new_span,
@@ -355,7 +372,10 @@ impl NuCompleter {
                                 }
 
                                 // Check for file completion
-                                let mut completer = FileCompletion::new();
+                                let mut completer = FileCompletion::new(
+                                    self.engine_state.clone(),
+                                    self.stack.clone(),
+                                );
                                 out = self.process_completion(
                                     &mut completer,
                                     &working_set,
@@ -540,7 +560,7 @@ mod completer_tests {
             result.err().unwrap()
         );
 
-        let mut completer = NuCompleter::new(engine_state.into(), Arc::new(Stack::new()));
+        let mut completer = NuCompleter::new(engine_state.into(), Stack::new());
         let dataset = [
             ("sudo", false, "", Vec::new()),
             ("sudo l", true, "l", vec!["ls", "let", "lines", "loop"]),

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

@@ -7,65 +7,40 @@ use nu_protocol::{
     Span,
 };
 use nu_utils::get_ls_colors;
-use std::path::{
+use std::{
-    is_separator, Component, Path, PathBuf, MAIN_SEPARATOR as SEP, MAIN_SEPARATOR_STR,
+    ffi::OsStr,
+    path::{is_separator, Component, Path, PathBuf, MAIN_SEPARATOR as SEP},
 };
 
-#[derive(Clone, Default)]
-pub struct PathBuiltFromString {
-    parts: Vec<String>,
-    isdir: bool,
-}
-
 fn complete_rec(
-    partial: &[&str],
+    partial: &[String],
-    built: &PathBuiltFromString,
     cwd: &Path,
     options: &CompletionOptions,
     dir: bool,
     isdir: bool,
-) -> Vec<PathBuiltFromString> {
+) -> Vec<PathBuf> {
     let mut completions = vec![];
 
-    if let Some((&base, rest)) = partial.split_first() {
+    if let Ok(result) = cwd.read_dir() {
-        if (base == "." || base == "..") && (isdir || !rest.is_empty()) {
+        for entry in result.filter_map(|e| e.ok()) {
-            let mut built = built.clone();
+            let entry_name = entry.file_name().to_string_lossy().into_owned();
-            built.parts.push(base.to_string());
+            let path = entry.path();
-            built.isdir = true;
-            return complete_rec(rest, &built, cwd, options, dir, isdir);
-        }
-    }
 
-    let mut built_path = cwd.to_path_buf();
+            if !dir || path.is_dir() {
-    for part in &built.parts {
+                match partial.first() {
-        built_path.push(part);
+                    Some(base) if matches(base, &entry_name, options) => {
-    }
+                        let partial = &partial[1..];
-
+                        if !partial.is_empty() || isdir {
-    let Ok(result) = built_path.read_dir() else {
+                            completions.extend(complete_rec(partial, &path, options, dir, isdir));
-        return completions;
+                            if entry_name.eq(base) {
-    };
+                                break;
-
+                            }
-    for entry in result.filter_map(|e| e.ok()) {
-        let entry_name = entry.file_name().to_string_lossy().into_owned();
-        let entry_isdir = entry.path().is_dir();
-        let mut built = built.clone();
-        built.parts.push(entry_name.clone());
-        built.isdir = entry_isdir;
-
-        if !dir || entry_isdir {
-            match partial.split_first() {
-                Some((base, rest)) => {
-                    if matches(base, &entry_name, options) {
-                        if !rest.is_empty() || isdir {
-                            completions
-                                .extend(complete_rec(rest, &built, cwd, options, dir, isdir));
                         } else {
-                            completions.push(built);
+                            completions.push(path)
                         }
                     }
-                }
+                    None => completions.push(path),
-                None => {
+                    _ => {}
-                    completions.push(built);
                 }
             }
         }
@@ -73,23 +48,33 @@ fn complete_rec(
     completions
 }
 
-#[derive(Debug)]
 enum OriginalCwd {
     None,
-    Home,
+    Home(PathBuf),
-    Prefix(String),
+    Some(PathBuf),
+    // referencing a single local file
+    Local(PathBuf),
 }
 
 impl OriginalCwd {
-    fn apply(&self, mut p: PathBuiltFromString) -> String {
+    fn apply(&self, p: &Path) -> String {
-        match self {
+        let mut ret = match self {
-            Self::None => {}
+            Self::None => p.to_string_lossy().into_owned(),
-            Self::Home => p.parts.insert(0, "~".to_string()),
+            Self::Some(base) => pathdiff::diff_paths(p, base)
-            Self::Prefix(s) => p.parts.insert(0, s.clone()),
+                .unwrap_or(p.to_path_buf())
+                .to_string_lossy()
+                .into_owned(),
+            Self::Home(home) => match p.strip_prefix(home) {
+                Ok(suffix) => format!("~{}{}", SEP, suffix.to_string_lossy()),
+                _ => p.to_string_lossy().into_owned(),
+            },
+            Self::Local(base) => Path::new(".")
+                .join(pathdiff::diff_paths(p, base).unwrap_or(p.to_path_buf()))
+                .to_string_lossy()
+                .into_owned(),
         };
 
-        let mut ret = p.parts.join(MAIN_SEPARATOR_STR);
+        if p.is_dir() {
-        if p.isdir {
             ret.push(SEP);
         }
         ret
@@ -131,67 +116,79 @@ pub fn complete_item(
             };
             get_ls_colors(ls_colors_env_str)
         });
-
-    let mut cwd = cwd_pathbuf.clone();
-    let mut prefix_len = 0;
     let mut original_cwd = OriginalCwd::None;
+    let mut components_vec: Vec<Component> = Path::new(&partial).components().collect();
 
-    let mut components = Path::new(&partial).components().peekable();
+    // Path components that end with a single "." get normalized away,
-    match components.peek().cloned() {
+    // so if the partial path ends in a literal "." we must add it back in manually
+    if partial.ends_with('.') && partial.len() > 1 {
+        components_vec.push(Component::Normal(OsStr::new(".")));
+    };
+    let mut components = components_vec.into_iter().peekable();
+
+    let mut cwd = match components.peek().cloned() {
         Some(c @ Component::Prefix(..)) => {
             // windows only by definition
             components.next();
             if let Some(Component::RootDir) = components.peek().cloned() {
                 components.next();
             };
-            cwd = [c, Component::RootDir].iter().collect();
+            [c, Component::RootDir].iter().collect()
-            prefix_len = c.as_os_str().len();
-            original_cwd = OriginalCwd::Prefix(c.as_os_str().to_string_lossy().into_owned());
         }
         Some(c @ Component::RootDir) => {
             components.next();
-            // This is kind of a hack. When joining an empty string with the rest,
+            PathBuf::from(c.as_os_str())
-            // we add the slash automagically
-            cwd = PathBuf::from(c.as_os_str());
-            prefix_len = 1;
-            original_cwd = OriginalCwd::Prefix(String::new());
         }
         Some(Component::Normal(home)) if home.to_string_lossy() == "~" => {
             components.next();
-            cwd = home_dir().unwrap_or(cwd_pathbuf);
+            original_cwd = OriginalCwd::Home(home_dir().unwrap_or(cwd_pathbuf.clone()));
-            prefix_len = 1;
+            home_dir().unwrap_or(cwd_pathbuf)
-            original_cwd = OriginalCwd::Home;
+        }
+        Some(Component::CurDir) => {
+            components.next();
+            original_cwd = match components.peek().cloned() {
+                Some(Component::Normal(_)) | None => OriginalCwd::Local(cwd_pathbuf.clone()),
+                _ => OriginalCwd::Some(cwd_pathbuf.clone()),
+            };
+            cwd_pathbuf
+        }
+        _ => {
+            original_cwd = OriginalCwd::Some(cwd_pathbuf.clone());
+            cwd_pathbuf
         }
-        _ => {}
     };
 
-    let after_prefix = &partial[prefix_len..];
+    let mut partial = vec![];
-    let partial: Vec<_> = after_prefix
-        .strip_prefix(is_separator)
-        .unwrap_or(after_prefix)
-        .split(is_separator)
-        .filter(|s| !s.is_empty())
-        .collect();
 
-    complete_rec(
+    for component in components {
-        partial.as_slice(),
+        match component {
-        &PathBuiltFromString::default(),
+            Component::Prefix(..) => unreachable!(),
-        &cwd,
+            Component::RootDir => unreachable!(),
-        options,
+            Component::CurDir => {}
-        want_directory,
+            Component::ParentDir => {
-        isdir,
+                if partial.pop().is_none() {
-    )
+                    cwd.pop();
-    .into_iter()
+                }
-    .map(|p| {
+            }
-        let path = original_cwd.apply(p);
+            Component::Normal(c) => partial.push(c.to_string_lossy().into_owned()),
-        let style = ls_colors.as_ref().map(|lsc| {
+        }
-            lsc.style_for_path_with_metadata(&path, std::fs::symlink_metadata(&path).ok().as_ref())
+    }
+
+    complete_rec(partial.as_slice(), &cwd, options, want_directory, isdir)
+        .into_iter()
+        .map(|p| {
+            let path = original_cwd.apply(&p);
+            let style = ls_colors.as_ref().map(|lsc| {
+                lsc.style_for_path_with_metadata(
+                    &path,
+                    std::fs::symlink_metadata(&path).ok().as_ref(),
+                )
                 .map(lscolors::Style::to_nu_ansi_term_style)
                 .unwrap_or_default()
-        });
+            });
-        (span, escape_path(path, want_directory), style)
+            (span, escape_path(path, want_directory), style)
-    })
+        })
-    .collect()
+        .collect()
 }
 
 // Fix files or folders with quotes or hashes

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

@@ -6,13 +6,14 @@ use nu_engine::eval_call;
 use nu_protocol::{
     ast::{Argument, Call, Expr, Expression},
     debugger::WithoutDebug,
-    engine::{Stack, StateWorkingSet},
+    engine::{EngineState, Stack, StateWorkingSet},
     PipelineData, Span, Type, Value,
 };
 use nu_utils::IgnoreCaseExt;
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
 
 pub struct CustomCompletion {
+    engine_state: Arc<EngineState>,
     stack: Stack,
     decl_id: usize,
     line: String,
@@ -20,9 +21,10 @@ pub struct CustomCompletion {
 }
 
 impl CustomCompletion {
-    pub fn new(stack: Stack, decl_id: usize, line: String) -> Self {
+    pub fn new(engine_state: Arc<EngineState>, stack: Stack, decl_id: usize, line: String) -> Self {
         Self {
-            stack,
+            engine_state,
+            stack: stack.reset_stdio().capture(),
             decl_id,
             line,
             sort_by: SortBy::None,
@@ -33,8 +35,7 @@ impl CustomCompletion {
 impl Completer for CustomCompletion {
     fn fetch(
         &mut self,
-        working_set: &StateWorkingSet,
+        _: &StateWorkingSet,
-        _stack: &Stack,
         prefix: Vec<u8>,
         span: Span,
         offset: usize,
@@ -46,7 +47,7 @@ impl Completer for CustomCompletion {
 
         // Call custom declaration
         let result = eval_call::<WithoutDebug>(
-            working_set.permanent_state,
+            &self.engine_state,
             &mut self.stack,
             &Call {
                 decl_id: self.decl_id,
@@ -74,53 +75,55 @@ impl Completer for CustomCompletion {
 
         // Parse result
         let suggestions = result
-            .and_then(|data| data.into_value(span))
+            .map(|pd| {
-            .map(|value| match &value {
+                let value = pd.into_value(span);
-                Value::Record { val, .. } => {
+                match &value {
-                    let completions = val
+                    Value::Record { val, .. } => {
-                        .get("completions")
+                        let completions = val
-                        .and_then(|val| {
+                            .get("completions")
-                            val.as_list()
+                            .and_then(|val| {
-                                .ok()
+                                val.as_list()
-                                .map(|it| map_value_completions(it.iter(), span, offset))
+                                    .ok()
-                        })
+                                    .map(|it| map_value_completions(it.iter(), span, offset))
-                        .unwrap_or_default();
+                            })
-                    let options = val.get("options");
+                            .unwrap_or_default();
+                        let options = val.get("options");
 
-                    if let Some(Value::Record { val: options, .. }) = &options {
+                        if let Some(Value::Record { val: options, .. }) = &options {
-                        let should_sort = options
+                            let should_sort = options
-                            .get("sort")
+                                .get("sort")
-                            .and_then(|val| val.as_bool().ok())
+                                .and_then(|val| val.as_bool().ok())
-                            .unwrap_or(false);
+                                .unwrap_or(false);
 
-                        if should_sort {
+                            if should_sort {
-                            self.sort_by = SortBy::Ascending;
+                                self.sort_by = SortBy::Ascending;
+                            }
+
+                            custom_completion_options = Some(CompletionOptions {
+                                case_sensitive: options
+                                    .get("case_sensitive")
+                                    .and_then(|val| val.as_bool().ok())
+                                    .unwrap_or(true),
+                                positional: options
+                                    .get("positional")
+                                    .and_then(|val| val.as_bool().ok())
+                                    .unwrap_or(true),
+                                match_algorithm: match options.get("completion_algorithm") {
+                                    Some(option) => option
+                                        .coerce_string()
+                                        .ok()
+                                        .and_then(|option| option.try_into().ok())
+                                        .unwrap_or(MatchAlgorithm::Prefix),
+                                    None => completion_options.match_algorithm,
+                                },
+                            });
                         }
 
-                        custom_completion_options = Some(CompletionOptions {
+                        completions
-                            case_sensitive: options
-                                .get("case_sensitive")
-                                .and_then(|val| val.as_bool().ok())
-                                .unwrap_or(true),
-                            positional: options
-                                .get("positional")
-                                .and_then(|val| val.as_bool().ok())
-                                .unwrap_or(true),
-                            match_algorithm: match options.get("completion_algorithm") {
-                                Some(option) => option
-                                    .coerce_string()
-                                    .ok()
-                                    .and_then(|option| option.try_into().ok())
-                                    .unwrap_or(MatchAlgorithm::Prefix),
-                                None => completion_options.match_algorithm,
-                            },
-                        });
                     }
-
+                    Value::List { vals, .. } => map_value_completions(vals.iter(), span, offset),
-                    completions
+                    _ => vec![],
                 }
-                Value::List { vals, .. } => map_value_completions(vals.iter(), span, offset),
-                _ => vec![],
             })
             .unwrap_or_default();
 

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

@@ -8,16 +8,25 @@ use nu_protocol::{
     levenshtein_distance, Span,
 };
 use reedline::Suggestion;
-use std::path::{Path, MAIN_SEPARATOR as SEP};
+use std::{
+    path::{Path, MAIN_SEPARATOR as SEP},
+    sync::Arc,
+};
 
 use super::SemanticSuggestion;
 
-#[derive(Clone, Default)]
+#[derive(Clone)]
-pub struct DirectoryCompletion {}
+pub struct DirectoryCompletion {
+    engine_state: Arc<EngineState>,
+    stack: Stack,
+}
 
 impl DirectoryCompletion {
-    pub fn new() -> Self {
+    pub fn new(engine_state: Arc<EngineState>, stack: Stack) -> Self {
-        Self::default()
+        Self {
+            engine_state,
+            stack,
+        }
     }
 }
 
@@ -25,24 +34,22 @@ impl Completer for DirectoryCompletion {
     fn fetch(
         &mut self,
         working_set: &StateWorkingSet,
-        stack: &Stack,
         prefix: Vec<u8>,
         span: Span,
         offset: usize,
-        _pos: usize,
+        _: usize,
         options: &CompletionOptions,
     ) -> Vec<SemanticSuggestion> {
         let AdjustView { prefix, span, .. } = adjust_if_intermediate(&prefix, working_set, span);
 
         // Filter only the folders
-        #[allow(deprecated)]
         let output: Vec<_> = directory_completion(
             span,
             &prefix,
-            &working_set.permanent_state.current_work_dir(),
+            &self.engine_state.current_work_dir(),
             options,
-            working_set.permanent_state,
+            self.engine_state.as_ref(),
-            stack,
+            &self.stack,
         )
         .into_iter()
         .map(move |x| SemanticSuggestion {

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

@@ -1,31 +1,39 @@
 use crate::completions::{file_path_completion, Completer, CompletionOptions, SortBy};
 use nu_protocol::{
-    engine::{Stack, StateWorkingSet},
+    engine::{EngineState, Stack, StateWorkingSet},
     Span,
 };
 use reedline::Suggestion;
-use std::path::{is_separator, Path, MAIN_SEPARATOR as SEP, MAIN_SEPARATOR_STR};
+use std::{
+    path::{is_separator, Path, MAIN_SEPARATOR as SEP, MAIN_SEPARATOR_STR},
+    sync::Arc,
+};
 
 use super::SemanticSuggestion;
 
-#[derive(Clone, Default)]
+#[derive(Clone)]
-pub struct DotNuCompletion {}
+pub struct DotNuCompletion {
+    engine_state: Arc<EngineState>,
+    stack: Stack,
+}
 
 impl DotNuCompletion {
-    pub fn new() -> Self {
+    pub fn new(engine_state: Arc<EngineState>, stack: Stack) -> Self {
-        Self::default()
+        Self {
+            engine_state,
+            stack,
+        }
     }
 }
 
 impl Completer for DotNuCompletion {
     fn fetch(
         &mut self,
-        working_set: &StateWorkingSet,
+        _: &StateWorkingSet,
-        stack: &Stack,
         prefix: Vec<u8>,
         span: Span,
         offset: usize,
-        _pos: usize,
+        _: usize,
         options: &CompletionOptions,
     ) -> Vec<SemanticSuggestion> {
         let prefix_str = String::from_utf8_lossy(&prefix).replace('`', "");
@@ -41,25 +49,26 @@ impl Completer for DotNuCompletion {
         let mut is_current_folder = false;
 
         // Fetch the lib dirs
-        let lib_dirs: Vec<String> = if let Some(lib_dirs) = working_set.get_env_var("NU_LIB_DIRS") {
+        let lib_dirs: Vec<String> =
-            lib_dirs
+            if let Some(lib_dirs) = self.engine_state.get_env_var("NU_LIB_DIRS") {
-                .as_list()
+                lib_dirs
-                .into_iter()
+                    .as_list()
-                .flat_map(|it| {
+                    .into_iter()
-                    it.iter().map(|x| {
+                    .flat_map(|it| {
-                        x.to_path()
+                        it.iter().map(|x| {
-                            .expect("internal error: failed to convert lib path")
+                            x.to_path()
+                                .expect("internal error: failed to convert lib path")
+                        })
                     })
-                })
+                    .map(|it| {
-                .map(|it| {
+                        it.into_os_string()
-                    it.into_os_string()
+                            .into_string()
-                        .into_string()
+                            .expect("internal error: failed to convert OS path")
-                        .expect("internal error: failed to convert OS path")
+                    })
-                })
+                    .collect()
-                .collect()
+            } else {
-        } else {
+                vec![]
-            vec![]
+            };
-        };
 
         // Check if the base_dir is a folder
         // rsplit_once removes the separator
@@ -75,8 +84,7 @@ impl Completer for DotNuCompletion {
             partial = base_dir_partial;
         } else {
             // Fetch the current folder
-            #[allow(deprecated)]
+            let current_folder = self.engine_state.current_work_dir();
-            let current_folder = working_set.permanent_state.current_work_dir();
             is_current_folder = true;
 
             // Add the current folder and the lib dirs into the
@@ -95,8 +103,8 @@ impl Completer for DotNuCompletion {
                     &partial,
                     &search_dir,
                     options,
-                    working_set.permanent_state,
+                    self.engine_state.as_ref(),
-                    stack,
+                    &self.stack,
                 );
                 completions
                     .into_iter()

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

@@ -9,16 +9,25 @@ use nu_protocol::{
 };
 use nu_utils::IgnoreCaseExt;
 use reedline::Suggestion;
-use std::path::{Path, MAIN_SEPARATOR as SEP};
+use std::{
+    path::{Path, MAIN_SEPARATOR as SEP},
+    sync::Arc,
+};
 
 use super::SemanticSuggestion;
 
-#[derive(Clone, Default)]
+#[derive(Clone)]
-pub struct FileCompletion {}
+pub struct FileCompletion {
+    engine_state: Arc<EngineState>,
+    stack: Stack,
+}
 
 impl FileCompletion {
-    pub fn new() -> Self {
+    pub fn new(engine_state: Arc<EngineState>, stack: Stack) -> Self {
-        Self::default()
+        Self {
+            engine_state,
+            stack,
+        }
     }
 }
 
@@ -26,11 +35,10 @@ impl Completer for FileCompletion {
     fn fetch(
         &mut self,
         working_set: &StateWorkingSet,
-        stack: &Stack,
         prefix: Vec<u8>,
         span: Span,
         offset: usize,
-        _pos: usize,
+        _: usize,
         options: &CompletionOptions,
     ) -> Vec<SemanticSuggestion> {
         let AdjustView {
@@ -39,15 +47,14 @@ impl Completer for FileCompletion {
             readjusted,
         } = adjust_if_intermediate(&prefix, working_set, span);
 
-        #[allow(deprecated)]
         let output: Vec<_> = complete_item(
             readjusted,
             span,
             &prefix,
-            &working_set.permanent_state.current_work_dir(),
+            &self.engine_state.current_work_dir(),
             options,
-            working_set.permanent_state,
+            self.engine_state.as_ref(),
-            stack,
+            &self.stack,
         )
         .into_iter()
         .map(move |x| SemanticSuggestion {

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

@@ -1,7 +1,7 @@
 use crate::completions::{Completer, CompletionOptions};
 use nu_protocol::{
     ast::{Expr, Expression},
-    engine::{Stack, StateWorkingSet},
+    engine::StateWorkingSet,
     Span,
 };
 use reedline::Suggestion;
@@ -23,11 +23,10 @@ impl Completer for FlagCompletion {
     fn fetch(
         &mut self,
         working_set: &StateWorkingSet,
-        _stack: &Stack,
         prefix: Vec<u8>,
         span: Span,
         offset: usize,
-        _pos: usize,
+        _: usize,
         options: &CompletionOptions,
     ) -> Vec<SemanticSuggestion> {
         // Check if it's a flag

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

@@ -3,20 +3,30 @@ use crate::completions::{
 };
 use nu_engine::{column::get_columns, eval_variable};
 use nu_protocol::{
-    engine::{Stack, StateWorkingSet},
+    engine::{EngineState, Stack, StateWorkingSet},
     Span, Value,
 };
 use reedline::Suggestion;
-use std::str;
+use std::{str, sync::Arc};
 
 #[derive(Clone)]
 pub struct VariableCompletion {
+    engine_state: Arc<EngineState>, // TODO: Is engine state necessary? It's already a part of working set in fetch()
+    stack: Stack,
     var_context: (Vec<u8>, Vec<Vec<u8>>), // tuple with $var and the sublevels (.b.c.d)
 }
 
 impl VariableCompletion {
-    pub fn new(var_context: (Vec<u8>, Vec<Vec<u8>>)) -> Self {
+    pub fn new(
-        Self { var_context }
+        engine_state: Arc<EngineState>,
+        stack: Stack,
+        var_context: (Vec<u8>, Vec<Vec<u8>>),
+    ) -> Self {
+        Self {
+            engine_state,
+            stack,
+            var_context,
+        }
     }
 }
 
@@ -24,11 +34,10 @@ impl Completer for VariableCompletion {
     fn fetch(
         &mut self,
         working_set: &StateWorkingSet,
-        stack: &Stack,
         prefix: Vec<u8>,
         span: Span,
         offset: usize,
-        _pos: usize,
+        _: usize,
         options: &CompletionOptions,
     ) -> Vec<SemanticSuggestion> {
         let mut output = vec![];
@@ -45,7 +54,7 @@ impl Completer for VariableCompletion {
         if !var_str.is_empty() {
             // Completion for $env.<tab>
             if var_str == "$env" {
-                let env_vars = stack.get_env_vars(working_set.permanent_state);
+                let env_vars = self.stack.get_env_vars(&self.engine_state);
 
                 // Return nested values
                 if sublevels_count > 0 {
@@ -59,7 +68,9 @@ impl Completer for VariableCompletion {
                         self.var_context.1.clone().into_iter().skip(1).collect();
 
                     if let Some(val) = env_vars.get(&target_var_str) {
-                        for suggestion in nested_suggestions(val, &nested_levels, current_span) {
+                        for suggestion in
+                            nested_suggestions(val.clone(), nested_levels, current_span)
+                        {
                             if options.match_algorithm.matches_u8_insensitive(
                                 options.case_sensitive,
                                 suggestion.suggestion.value.as_bytes(),
@@ -101,12 +112,13 @@ impl Completer for VariableCompletion {
             if var_str == "$nu" {
                 // Eval nu var
                 if let Ok(nuval) = eval_variable(
-                    working_set.permanent_state,
+                    &self.engine_state,
-                    stack,
+                    &self.stack,
                     nu_protocol::NU_VARIABLE_ID,
                     nu_protocol::Span::new(current_span.start, current_span.end),
                 ) {
-                    for suggestion in nested_suggestions(&nuval, &self.var_context.1, current_span)
+                    for suggestion in
+                        nested_suggestions(nuval, self.var_context.1.clone(), current_span)
                     {
                         if options.match_algorithm.matches_u8_insensitive(
                             options.case_sensitive,
@@ -124,11 +136,12 @@ impl Completer for VariableCompletion {
             // Completion other variable types
             if let Some(var_id) = var_id {
                 // Extract the variable value from the stack
-                let var = stack.get_var(var_id, Span::new(span.start, span.end));
+                let var = self.stack.get_var(var_id, Span::new(span.start, span.end));
 
                 // If the value exists and it's of type Record
                 if let Ok(value) = var {
-                    for suggestion in nested_suggestions(&value, &self.var_context.1, current_span)
+                    for suggestion in
+                        nested_suggestions(value, self.var_context.1.clone(), current_span)
                     {
                         if options.match_algorithm.matches_u8_insensitive(
                             options.case_sensitive,
@@ -198,11 +211,7 @@ impl Completer for VariableCompletion {
 
         // Permanent state vars
         // for scope in &self.engine_state.scope {
-        for overlay_frame in working_set
+        for overlay_frame in self.engine_state.active_overlays(&removed_overlays).rev() {
-            .permanent_state
-            .active_overlays(&removed_overlays)
-            .rev()
-        {
             for v in &overlay_frame.vars {
                 if options.match_algorithm.matches_u8_insensitive(
                     options.case_sensitive,
@@ -235,21 +244,39 @@ impl Completer for VariableCompletion {
 // Find recursively the values for sublevels
 // if no sublevels are set it returns the current value
 fn nested_suggestions(
-    val: &Value,
+    val: Value,
-    sublevels: &[Vec<u8>],
+    sublevels: Vec<Vec<u8>>,
     current_span: reedline::Span,
 ) -> Vec<SemanticSuggestion> {
     let mut output: Vec<SemanticSuggestion> = vec![];
-    let value = recursive_value(val, sublevels).unwrap_or_else(Value::nothing);
+    let value = recursive_value(val, sublevels);
 
     let kind = SuggestionKind::Type(value.get_type());
     match value {
         Value::Record { val, .. } => {
             // Add all the columns as completion
-            for col in val.columns() {
+            for (col, _) in val.into_iter() {
                 output.push(SemanticSuggestion {
                     suggestion: Suggestion {
-                        value: col.clone(),
+                        value: col,
+                        description: None,
+                        style: None,
+                        extra: None,
+                        span: current_span,
+                        append_whitespace: false,
+                    },
+                    kind: Some(kind.clone()),
+                });
+            }
+
+            output
+        }
+        Value::LazyRecord { val, .. } => {
+            // Add all the columns as completion
+            for column_name in val.column_names() {
+                output.push(SemanticSuggestion {
+                    suggestion: Suggestion {
+                        value: column_name.to_string(),
                         description: None,
                         style: None,
                         extra: None,
@@ -284,36 +311,56 @@ fn nested_suggestions(
 }
 
 // Extracts the recursive value (e.g: $var.a.b.c)
-fn recursive_value(val: &Value, sublevels: &[Vec<u8>]) -> Result<Value, Span> {
+fn recursive_value(val: Value, sublevels: Vec<Vec<u8>>) -> Value {
     // Go to next sublevel
-    if let Some((sublevel, next_sublevels)) = sublevels.split_first() {
+    if let Some(next_sublevel) = sublevels.clone().into_iter().next() {
         let span = val.span();
         match val {
             Value::Record { val, .. } => {
-                if let Some((_, value)) = val.iter().find(|(key, _)| key.as_bytes() == sublevel) {
+                for item in *val {
-                    // If matches try to fetch recursively the next
+                    // Check if index matches with sublevel
-                    recursive_value(value, next_sublevels)
+                    if item.0.as_bytes().to_vec() == next_sublevel {
-                } else {
+                        // If matches try to fetch recursively the next
-                    // Current sublevel value not found
+                        return recursive_value(item.1, sublevels.into_iter().skip(1).collect());
-                    Err(span)
-                }
-            }
-            Value::List { vals, .. } => {
-                for col in get_columns(vals.as_slice()) {
-                    if col.as_bytes() == *sublevel {
-                        let val = val.get_data_by_key(&col).ok_or(span)?;
-                        return recursive_value(&val, next_sublevels);
                     }
                 }
 
                 // Current sublevel value not found
-                Err(span)
+                return Value::nothing(span);
             }
-            _ => Ok(val.clone()),
+            Value::LazyRecord { val, .. } => {
+                for col in val.column_names() {
+                    if col.as_bytes().to_vec() == next_sublevel {
+                        return recursive_value(
+                            val.get_column_value(col).unwrap_or_default(),
+                            sublevels.into_iter().skip(1).collect(),
+                        );
+                    }
+                }
+
+                // Current sublevel value not found
+                return Value::nothing(span);
+            }
+            Value::List { vals, .. } => {
+                for col in get_columns(vals.as_slice()) {
+                    if col.as_bytes().to_vec() == next_sublevel {
+                        return recursive_value(
+                            Value::list(vals, span)
+                                .get_data_by_key(&col)
+                                .unwrap_or_default(),
+                            sublevels.into_iter().skip(1).collect(),
+                        );
+                    }
+                }
+
+                // Current sublevel value not found
+                return Value::nothing(span);
+            }
+            _ => return val,
         }
-    } else {
-        Ok(val.clone())
     }
+
+    val
 }
 
 impl MatchAlgorithm {

crates/nu-cli/src/config_files.rs

@@ -1,20 +1,18 @@
 use crate::util::eval_source;
 #[cfg(feature = "plugin")]
 use nu_path::canonicalize_with;
-#[cfg(feature = "plugin")]
-use nu_protocol::{engine::StateWorkingSet, report_error, ParseError, PluginRegistryFile, Spanned};
 use nu_protocol::{
-    engine::{EngineState, Stack},
+    engine::{EngineState, Stack, StateWorkingSet},
-    report_error_new, HistoryFileFormat, PipelineData,
+    report_error, HistoryFileFormat, PipelineData,
 };
 #[cfg(feature = "plugin")]
+use nu_protocol::{ParseError, Spanned};
+#[cfg(feature = "plugin")]
 use nu_utils::utils::perf;
 use std::path::PathBuf;
 
 #[cfg(feature = "plugin")]
-const PLUGIN_FILE: &str = "plugin.msgpackz";
+const PLUGIN_FILE: &str = "plugin.nu";
-#[cfg(feature = "plugin")]
-const OLD_PLUGIN_FILE: &str = "plugin.nu";
 
 const HISTORY_FILE_TXT: &str = "history.txt";
 const HISTORY_FILE_SQLITE: &str = "history.sqlite3";
@@ -22,149 +20,40 @@ const HISTORY_FILE_SQLITE: &str = "history.sqlite3";
 #[cfg(feature = "plugin")]
 pub fn read_plugin_file(
     engine_state: &mut EngineState,
+    stack: &mut Stack,
     plugin_file: Option<Spanned<String>>,
     storage_path: &str,
 ) {
-    use nu_protocol::ShellError;
+    let start_time = std::time::Instant::now();
-    use std::path::Path;
+    let mut plug_path = String::new();
+    // Reading signatures from signature file
+    // The plugin.nu file stores the parsed signature collected from each registered plugin
+    add_plugin_file(engine_state, plugin_file, storage_path);
 
-    let span = plugin_file.as_ref().map(|s| s.span);
+    let plugin_path = engine_state.plugin_signatures.clone();
-
+    if let Some(plugin_path) = plugin_path {
-    // Check and warn + abort if this is a .nu plugin file
+        let plugin_filename = plugin_path.to_string_lossy();
-    if plugin_file
+        plug_path = plugin_filename.to_string();
-        .as_ref()
+        if let Ok(contents) = std::fs::read(&plugin_path) {
-        .and_then(|p| Path::new(&p.item).extension())
+            eval_source(
-        .is_some_and(|ext| ext == "nu")
+                engine_state,
-    {
+                stack,
-        report_error_new(
+                &contents,
-            engine_state,
+                &plugin_filename,
-            &ShellError::GenericError {
+                PipelineData::empty(),
-                error: "Wrong plugin file format".into(),
+                false,
-                msg: ".nu plugin files are no longer supported".into(),
+            );
-                span,
+        }
-                help: Some("please recreate this file in the new .msgpackz format".into()),
-                inner: vec![],
-            },
-        );
-        return;
     }
 
-    let mut start_time = std::time::Instant::now();
-    // Reading signatures from plugin registry file
-    // The plugin.msgpackz file stores the parsed signature collected from each registered plugin
-    add_plugin_file(engine_state, plugin_file.clone(), storage_path);
     perf(
-        "add plugin file to engine_state",
+        &format!("read_plugin_file {}", &plug_path),
         start_time,
         file!(),
         line!(),
         column!(),
         engine_state.get_config().use_ansi_coloring,
     );
-
-    start_time = std::time::Instant::now();
-    let plugin_path = engine_state.plugin_path.clone();
-    if let Some(plugin_path) = plugin_path {
-        // Open the plugin file
-        let mut file = match std::fs::File::open(&plugin_path) {
-            Ok(file) => file,
-            Err(err) => {
-                if err.kind() == std::io::ErrorKind::NotFound {
-                    log::warn!("Plugin file not found: {}", plugin_path.display());
-
-                    // Try migration of an old plugin file if this wasn't a custom plugin file
-                    if plugin_file.is_none() && migrate_old_plugin_file(engine_state, storage_path)
-                    {
-                        let Ok(file) = std::fs::File::open(&plugin_path) else {
-                            log::warn!("Failed to load newly migrated plugin file");
-                            return;
-                        };
-                        file
-                    } else {
-                        return;
-                    }
-                } else {
-                    report_error_new(
-                        engine_state,
-                        &ShellError::GenericError {
-                            error: format!(
-                                "Error while opening plugin registry file: {}",
-                                plugin_path.display()
-                            ),
-                            msg: "plugin path defined here".into(),
-                            span,
-                            help: None,
-                            inner: vec![err.into()],
-                        },
-                    );
-                    return;
-                }
-            }
-        };
-
-        // Abort if the file is empty.
-        if file.metadata().is_ok_and(|m| m.len() == 0) {
-            log::warn!(
-                "Not reading plugin file because it's empty: {}",
-                plugin_path.display()
-            );
-            return;
-        }
-
-        // Read the contents of the plugin file
-        let contents = match PluginRegistryFile::read_from(&mut file, span) {
-            Ok(contents) => contents,
-            Err(err) => {
-                log::warn!("Failed to read plugin registry file: {err:?}");
-                report_error_new(
-                    engine_state,
-                    &ShellError::GenericError {
-                        error: format!(
-                            "Error while reading plugin registry file: {}",
-                            plugin_path.display()
-                        ),
-                        msg: "plugin path defined here".into(),
-                        span,
-                        help: Some(
-                            "you might try deleting the file and registering all of your \
-                                plugins again"
-                                .into(),
-                        ),
-                        inner: vec![],
-                    },
-                );
-                return;
-            }
-        };
-
-        perf(
-            &format!("read plugin file {}", plugin_path.display()),
-            start_time,
-            file!(),
-            line!(),
-            column!(),
-            engine_state.get_config().use_ansi_coloring,
-        );
-        start_time = std::time::Instant::now();
-
-        let mut working_set = StateWorkingSet::new(engine_state);
-
-        nu_plugin_engine::load_plugin_file(&mut working_set, &contents, span);
-
-        if let Err(err) = engine_state.merge_delta(working_set.render()) {
-            report_error_new(engine_state, &err);
-            return;
-        }
-
-        perf(
-            &format!("load plugin file {}", plugin_path.display()),
-            start_time,
-            file!(),
-            line!(),
-            column!(),
-            engine_state.get_config().use_ansi_coloring,
-        );
-    }
 }
 
 #[cfg(feature = "plugin")]
@@ -173,39 +62,23 @@ pub fn add_plugin_file(
     plugin_file: Option<Spanned<String>>,
     storage_path: &str,
 ) {
-    use std::path::Path;
-
     let working_set = StateWorkingSet::new(engine_state);
+    let cwd = working_set.get_cwd();
 
-    if let Ok(cwd) = engine_state.cwd_as_string(None) {
+    if let Some(plugin_file) = plugin_file {
-        if let Some(plugin_file) = plugin_file {
+        if let Ok(path) = canonicalize_with(&plugin_file.item, cwd) {
-            let path = Path::new(&plugin_file.item);
+            engine_state.plugin_signatures = Some(path)
-            let path_dir = path.parent().unwrap_or(path);
+        } else {
-            // Just try to canonicalize the directory of the plugin file first.
+            let e = ParseError::FileNotFound(plugin_file.item, plugin_file.span);
-            if let Ok(path_dir) = canonicalize_with(path_dir, &cwd) {
+            report_error(&working_set, &e);
-                // Try to canonicalize the actual filename, but it's ok if that fails. The file doesn't
-                // have to exist.
-                let path = path_dir.join(path.file_name().unwrap_or(path.as_os_str()));
-                let path = canonicalize_with(&path, &cwd).unwrap_or(path);
-                engine_state.plugin_path = Some(path)
-            } else {
-                // It's an error if the directory for the plugin file doesn't exist.
-                report_error(
-                    &working_set,
-                    &ParseError::FileNotFound(
-                        path_dir.to_string_lossy().into_owned(),
-                        plugin_file.span,
-                    ),
-                );
-            }
-        } else if let Some(mut plugin_path) = nu_path::config_dir() {
-            // Path to store plugins signatures
-            plugin_path.push(storage_path);
-            let mut plugin_path = canonicalize_with(&plugin_path, &cwd).unwrap_or(plugin_path);
-            plugin_path.push(PLUGIN_FILE);
-            let plugin_path = canonicalize_with(&plugin_path, &cwd).unwrap_or(plugin_path);
-            engine_state.plugin_path = Some(plugin_path);
         }
+    } else if let Some(mut plugin_path) = nu_path::config_dir() {
+        // Path to store plugins signatures
+        plugin_path.push(storage_path);
+        let mut plugin_path = canonicalize_with(&plugin_path, &cwd).unwrap_or(plugin_path);
+        plugin_path.push(PLUGIN_FILE);
+        let plugin_path = canonicalize_with(&plugin_path, &cwd).unwrap_or(plugin_path);
+        engine_state.plugin_signatures = Some(plugin_path);
     }
 }
 
@@ -218,10 +91,6 @@ pub fn eval_config_contents(
         let config_filename = config_path.to_string_lossy();
 
         if let Ok(contents) = std::fs::read(&config_path) {
-            // Set the current active file to the config file.
-            let prev_file = engine_state.file.take();
-            engine_state.file = Some(config_path.clone());
-
             eval_source(
                 engine_state,
                 stack,
@@ -231,18 +100,17 @@ pub fn eval_config_contents(
                 false,
             );
 
-            // Restore the current active file.
-            engine_state.file = prev_file;
-
             // Merge the environment in case env vars changed in the config
-            match engine_state.cwd(Some(stack)) {
+            match nu_engine::env::current_dir(engine_state, stack) {
                 Ok(cwd) => {
                     if let Err(e) = engine_state.merge_env(stack, cwd) {
-                        report_error_new(engine_state, &e);
+                        let working_set = StateWorkingSet::new(engine_state);
+                        report_error(&working_set, &e);
                     }
                 }
                 Err(e) => {
-                    report_error_new(engine_state, &e);
+                    let working_set = StateWorkingSet::new(engine_state);
+                    report_error(&working_set, &e);
                 }
             }
         }
@@ -259,132 +127,3 @@ pub(crate) fn get_history_path(storage_path: &str, mode: HistoryFileFormat) -> O
         history_path
     })
 }
-
-#[cfg(feature = "plugin")]
-pub fn migrate_old_plugin_file(engine_state: &EngineState, storage_path: &str) -> bool {
-    use nu_protocol::{
-        PluginExample, PluginIdentity, PluginRegistryItem, PluginRegistryItemData, PluginSignature,
-        ShellError,
-    };
-    use std::collections::BTreeMap;
-
-    let start_time = std::time::Instant::now();
-
-    let Ok(cwd) = engine_state.cwd_as_string(None) else {
-        return false;
-    };
-
-    let Some(config_dir) = nu_path::config_dir().and_then(|mut dir| {
-        dir.push(storage_path);
-        nu_path::canonicalize_with(dir, &cwd).ok()
-    }) else {
-        return false;
-    };
-
-    let Ok(old_plugin_file_path) = nu_path::canonicalize_with(OLD_PLUGIN_FILE, &config_dir) else {
-        return false;
-    };
-
-    let old_contents = match std::fs::read(&old_plugin_file_path) {
-        Ok(old_contents) => old_contents,
-        Err(err) => {
-            report_error_new(
-                engine_state,
-                &ShellError::GenericError {
-                    error: "Can't read old plugin file to migrate".into(),
-                    msg: "".into(),
-                    span: None,
-                    help: Some(err.to_string()),
-                    inner: vec![],
-                },
-            );
-            return false;
-        }
-    };
-
-    // Make a copy of the engine state, because we'll read the newly generated file
-    let mut engine_state = engine_state.clone();
-    let mut stack = Stack::new();
-
-    if eval_source(
-        &mut engine_state,
-        &mut stack,
-        &old_contents,
-        &old_plugin_file_path.to_string_lossy(),
-        PipelineData::Empty,
-        false,
-    ) != 0
-    {
-        return false;
-    }
-
-    // Now that the plugin commands are loaded, we just have to generate the file
-    let mut contents = PluginRegistryFile::new();
-
-    let mut groups = BTreeMap::<PluginIdentity, Vec<PluginSignature>>::new();
-
-    for decl in engine_state.plugin_decls() {
-        if let Some(identity) = decl.plugin_identity() {
-            groups
-                .entry(identity.clone())
-                .or_default()
-                .push(PluginSignature {
-                    sig: decl.signature(),
-                    examples: decl
-                        .examples()
-                        .into_iter()
-                        .map(PluginExample::from)
-                        .collect(),
-                })
-        }
-    }
-
-    for (identity, commands) in groups {
-        contents.upsert_plugin(PluginRegistryItem {
-            name: identity.name().to_owned(),
-            filename: identity.filename().to_owned(),
-            shell: identity.shell().map(|p| p.to_owned()),
-            data: PluginRegistryItemData::Valid { commands },
-        });
-    }
-
-    // Write the new file
-    let new_plugin_file_path = config_dir.join(PLUGIN_FILE);
-    if let Err(err) = std::fs::File::create(&new_plugin_file_path)
-        .map_err(|e| e.into())
-        .and_then(|file| contents.write_to(file, None))
-    {
-        report_error_new(
-            &engine_state,
-            &ShellError::GenericError {
-                error: "Failed to save migrated plugin file".into(),
-                msg: "".into(),
-                span: None,
-                help: Some("ensure `$nu.plugin-path` is writable".into()),
-                inner: vec![err],
-            },
-        );
-        return false;
-    }
-
-    if engine_state.is_interactive {
-        eprintln!(
-            "Your old plugin.nu file has been migrated to the new format: {}",
-            new_plugin_file_path.display()
-        );
-        eprintln!(
-            "The plugin.nu file has not been removed. If `plugin list` looks okay, \
-            you may do so manually."
-        );
-    }
-
-    perf(
-        "migrate old plugin file",
-        start_time,
-        file!(),
-        line!(),
-        column!(),
-        engine_state.get_config().use_ansi_coloring,
-    );
-    true
-}

crates/nu-cli/src/eval_cmds.rs

@@ -1,12 +1,12 @@
 use log::info;
+use miette::Result;
 use nu_engine::{convert_env_values, eval_block};
 use nu_parser::parse;
 use nu_protocol::{
     debugger::WithoutDebug,
     engine::{EngineState, Stack, StateWorkingSet},
-    report_error, PipelineData, ShellError, Spanned, Value,
+    report_error, PipelineData, Spanned, Value,
 };
-use std::sync::Arc;
 
 /// Run a command (or commands) given to us by the user
 pub fn evaluate_commands(
@@ -15,10 +15,13 @@ pub fn evaluate_commands(
     stack: &mut Stack,
     input: PipelineData,
     table_mode: Option<Value>,
-    no_newline: bool,
+) -> Result<Option<i64>> {
-) -> Result<(), ShellError> {
     // Translate environment variables from Strings to Values
-    convert_env_values(engine_state, stack)?;
+    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) = {
@@ -37,6 +40,7 @@ pub fn evaluate_commands(
 
         if let Some(err) = working_set.parse_errors.first() {
             report_error(&working_set, err);
+
             std::process::exit(1);
         }
 
@@ -44,27 +48,29 @@ pub fn evaluate_commands(
     };
 
     // Update permanent state
-    engine_state.merge_delta(delta)?;
+    if let Err(err) = engine_state.merge_delta(delta) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &err);
+    }
 
     // Run the block
-    let pipeline = eval_block::<WithoutDebug>(engine_state, stack, &block, input)?;
+    let exit_code = match eval_block::<WithoutDebug>(engine_state, stack, &block, input) {
-
+        Ok(pipeline_data) => {
-    if let PipelineData::Value(Value::Error { error, .. }, ..) = pipeline {
+            let mut config = engine_state.get_config().clone();
-        return Err(*error);
+            if let Some(t_mode) = table_mode {
-    }
+                config.table_mode = t_mode.coerce_str()?.parse().unwrap_or_default();
-
+            }
-    if let Some(t_mode) = table_mode {
+            crate::eval_file::print_table_or_error(engine_state, stack, pipeline_data, &mut config)
-        Arc::make_mut(&mut engine_state.config).table_mode =
-            t_mode.coerce_str()?.parse().unwrap_or_default();
-    }
-
-    if let Some(status) = pipeline.print(engine_state, stack, no_newline, false)? {
-        if status.code() != 0 {
-            std::process::exit(status.code())
         }
-    }
+        Err(err) => {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &err);
+            std::process::exit(1);
+        }
+    };
 
     info!("evaluate {}:{}:{}", file!(), line!(), column!());
 
-    Ok(())
+    Ok(exit_code)
 }

crates/nu-cli/src/eval_file.rs

@@ -1,59 +1,93 @@
 use crate::util::eval_source;
 use log::{info, trace};
-use nu_engine::{convert_env_values, eval_block};
+use miette::{IntoDiagnostic, Result};
+use nu_engine::{convert_env_values, current_dir, eval_block};
 use nu_parser::parse;
 use nu_path::canonicalize_with;
 use nu_protocol::{
+    ast::Call,
     debugger::WithoutDebug,
     engine::{EngineState, Stack, StateWorkingSet},
-    report_error, PipelineData, ShellError, Span, Value,
+    report_error, Config, PipelineData, ShellError, Span, Value,
 };
+use nu_utils::stdout_write_all_and_flush;
 use std::sync::Arc;
 
-/// Entry point for evaluating a file.
+/// Main function used when a file path is found as argument for nu
-///
-/// If the file contains a main command, it is invoked with `args` and the pipeline data from `input`;
-/// otherwise, the pipeline data is forwarded to the first command in the file, and `args` are ignored.
 pub fn evaluate_file(
     path: String,
     args: &[String],
     engine_state: &mut EngineState,
     stack: &mut Stack,
     input: PipelineData,
-) -> Result<(), ShellError> {
+) -> Result<()> {
-    // Convert environment variables from Strings to Values and store them in the engine state.
+    // Translate environment variables from Strings to Values
-    convert_env_values(engine_state, stack)?;
+    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);
+    }
 
-    let cwd = engine_state.cwd_as_string(Some(stack))?;
+    let cwd = current_dir(engine_state, stack)?;
 
-    let file_path =
+    let file_path = canonicalize_with(&path, cwd).unwrap_or_else(|e| {
-        canonicalize_with(&path, cwd).map_err(|err| ShellError::FileNotFoundCustom {
+        let working_set = StateWorkingSet::new(engine_state);
-            msg: format!("Could not access file '{path}': {err}"),
+        report_error(
-            span: Span::unknown(),
+            &working_set,
-        })?;
+            &ShellError::FileNotFoundCustom {
+                msg: format!("Could not access file '{}': {:?}", path, e.to_string()),
+                span: Span::unknown(),
+            },
+        );
+        std::process::exit(1);
+    });
 
-    let file_path_str = file_path
+    let file_path_str = file_path.to_str().unwrap_or_else(|| {
-        .to_str()
+        let working_set = StateWorkingSet::new(engine_state);
-        .ok_or_else(|| ShellError::NonUtf8Custom {
+        report_error(
-            msg: format!(
+            &working_set,
-                "Input file name '{}' is not valid UTF8",
+            &ShellError::NonUtf8Custom {
-                file_path.to_string_lossy()
+                msg: format!(
-            ),
+                    "Input file name '{}' is not valid UTF8",
-            span: Span::unknown(),
+                    file_path.to_string_lossy()
-        })?;
+                ),
+                span: Span::unknown(),
+            },
+        );
+        std::process::exit(1);
+    });
 
-    let file = std::fs::read(&file_path).map_err(|err| ShellError::FileNotFoundCustom {
+    let file = std::fs::read(&file_path)
-        msg: format!("Could not read file '{file_path_str}': {err}"),
+        .into_diagnostic()
-        span: Span::unknown(),
+        .unwrap_or_else(|e| {
-    })?;
+            let working_set = StateWorkingSet::new(engine_state);
-    engine_state.file = Some(file_path.clone());
+            report_error(
+                &working_set,
+                &ShellError::FileNotFoundCustom {
+                    msg: format!(
+                        "Could not read file '{}': {:?}",
+                        file_path_str,
+                        e.to_string()
+                    ),
+                    span: Span::unknown(),
+                },
+            );
+            std::process::exit(1);
+        });
 
-    let parent = file_path
+    engine_state.start_in_file(Some(file_path_str));
-        .parent()
+
-        .ok_or_else(|| ShellError::FileNotFoundCustom {
+    let parent = file_path.parent().unwrap_or_else(|| {
-            msg: format!("The file path '{file_path_str}' does not have a parent"),
+        let working_set = StateWorkingSet::new(engine_state);
-            span: Span::unknown(),
+        report_error(
-        })?;
+            &working_set,
+            &ShellError::FileNotFoundCustom {
+                msg: format!("The file path '{file_path_str}' does not have a parent"),
+                span: Span::unknown(),
+            },
+        );
+        std::process::exit(1);
+    });
 
     stack.add_env_var(
         "FILE_PWD".to_string(),
@@ -70,19 +104,17 @@ pub fn evaluate_file(
 
     let source_filename = file_path
         .file_name()
-        .expect("internal error: missing filename");
+        .expect("internal error: script missing filename");
 
     let mut working_set = StateWorkingSet::new(engine_state);
     trace!("parsing file: {}", file_path_str);
     let block = parse(&mut working_set, Some(file_path_str), &file, false);
 
-    // If any parse errors were found, report the first error and exit.
     if let Some(err) = working_set.parse_errors.first() {
         report_error(&working_set, err);
         std::process::exit(1);
     }
 
-    // Look for blocks whose name starts with "main" and replace it with the filename.
     for block in working_set.delta.blocks.iter_mut().map(Arc::make_mut) {
         if block.signature.name == "main" {
             block.signature.name = source_filename.to_string_lossy().to_string();
@@ -92,49 +124,131 @@ pub fn evaluate_file(
         }
     }
 
-    // Merge the changes into the engine state.
+    let _ = engine_state.merge_delta(working_set.delta);
-    engine_state.merge_delta(working_set.delta)?;
 
-    // Check if the file contains a main command.
+    if engine_state.find_decl(b"main", &[]).is_some() {
-    let exit_code = if engine_state.find_decl(b"main", &[]).is_some() {
+        let args = format!("main {}", args.join(" "));
-        // Evaluate the file, but don't run main yet.
+
-        let pipeline =
+        let pipeline_data =
-            match eval_block::<WithoutDebug>(engine_state, stack, &block, PipelineData::empty()) {
+            eval_block::<WithoutDebug>(engine_state, stack, &block, PipelineData::empty());
-                Ok(data) => data,
+        let pipeline_data = match pipeline_data {
-                Err(ShellError::Return { .. }) => {
+            Err(ShellError::Return { .. }) => {
-                    // Allow early return before main is run.
+                // allows early exists before `main` is run.
-                    return Ok(());
+                return Ok(());
+            }
+
+            x => x,
+        }
+        .unwrap_or_else(|e| {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
+            std::process::exit(1);
+        });
+
+        let result = pipeline_data.print(engine_state, stack, true, false);
+
+        match result {
+            Err(err) => {
+                let working_set = StateWorkingSet::new(engine_state);
+
+                report_error(&working_set, &err);
+                std::process::exit(1);
+            }
+            Ok(exit_code) => {
+                if exit_code != 0 {
+                    std::process::exit(exit_code as i32);
                 }
-                Err(err) => return Err(err),
-            };
-
-        // Print the pipeline output of the last command of the file.
-        if let Some(status) = pipeline.print(engine_state, stack, true, false)? {
-            if status.code() != 0 {
-                std::process::exit(status.code())
             }
         }
 
-        // Invoke the main command with arguments.
+        if !eval_source(
-        // Arguments with whitespaces are quoted, thus can be safely concatenated by whitespace.
-        let args = format!("main {}", args.join(" "));
-        eval_source(
             engine_state,
             stack,
             args.as_bytes(),
             "<commandline>",
             input,
             true,
-        )
+        ) {
-    } else {
+            std::process::exit(1);
-        eval_source(engine_state, stack, &file, file_path_str, input, true)
+        }
-    };
+    } else if !eval_source(engine_state, stack, &file, file_path_str, input, true) {
-
+        std::process::exit(1);
-    if exit_code != 0 {
-        std::process::exit(exit_code)
     }
 
     info!("evaluate {}:{}:{}", file!(), line!(), column!());
 
     Ok(())
 }
+
+pub(crate) fn print_table_or_error(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    mut pipeline_data: PipelineData,
+    config: &mut Config,
+) -> Option<i64> {
+    let exit_code = match &mut pipeline_data {
+        PipelineData::ExternalStream { exit_code, .. } => exit_code.take(),
+        _ => None,
+    };
+
+    // Change the engine_state config to use the passed in configuration
+    engine_state.set_config(config.clone());
+
+    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);
+    }
+
+    if let Some(decl_id) = engine_state.find_decl("table".as_bytes(), &[]) {
+        let command = engine_state.get_decl(decl_id);
+        if command.get_block_id().is_some() {
+            print_or_exit(pipeline_data, engine_state, config);
+        } else {
+            // The final call on table command, it's ok to set redirect_output to false.
+            let call = Call::new(Span::new(0, 0));
+            let table = command.run(engine_state, stack, &call, pipeline_data);
+
+            match table {
+                Ok(table) => {
+                    print_or_exit(table, engine_state, config);
+                }
+                Err(error) => {
+                    let working_set = StateWorkingSet::new(engine_state);
+                    report_error(&working_set, &error);
+                    std::process::exit(1);
+                }
+            }
+        }
+    } else {
+        print_or_exit(pipeline_data, engine_state, config);
+    }
+
+    // Make sure everything has finished
+    if let Some(exit_code) = exit_code {
+        let mut exit_code: Vec<_> = exit_code.into_iter().collect();
+        exit_code
+            .pop()
+            .and_then(|last_exit_code| match last_exit_code {
+                Value::Int { val: code, .. } => Some(code),
+                _ => None,
+            })
+    } else {
+        None
+    }
+}
+
+fn print_or_exit(pipeline_data: PipelineData, engine_state: &mut EngineState, config: &Config) {
+    for item in pipeline_data {
+        if let Value::Error { error, .. } = item {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &*error);
+
+            std::process::exit(1);
+        }
+
+        let out = item.to_expanded_string("\n", config) + "\n";
+        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{err}"));
+    }
+}

crates/nu-cli/src/lib.rs

@@ -32,6 +32,4 @@ pub use validation::NuValidator;
 #[cfg(feature = "plugin")]
 pub use config_files::add_plugin_file;
 #[cfg(feature = "plugin")]
-pub use config_files::migrate_old_plugin_file;
-#[cfg(feature = "plugin")]
 pub use config_files::read_plugin_file;

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

@@ -12,49 +12,50 @@ impl NuHelpCompleter {
     }
 
     fn completion_helper(&self, line: &str, pos: usize) -> Vec<Suggestion> {
+        let full_commands = self.0.get_signatures_with_examples(false);
         let folded_line = line.to_folded_case();
 
-        let mut commands = self
+        //Vec<(Signature, Vec<Example>, bool, bool)> {
-            .0
+        let mut commands = full_commands
-            .get_decls_sorted(false)
+            .iter()
-            .into_iter()
+            .filter(|(sig, _, _, _, _)| {
-            .filter_map(|(_, decl_id)| {
+                sig.name.to_folded_case().contains(&folded_line)
-                let decl = self.0.get_decl(decl_id);
+                    || sig.usage.to_folded_case().contains(&folded_line)
-                (decl.name().to_folded_case().contains(&folded_line)
+                    || sig
-                    || decl.usage().to_folded_case().contains(&folded_line)
+                        .search_terms
-                    || decl
+                        .iter()
-                        .search_terms()
-                        .into_iter()
                         .any(|term| term.to_folded_case().contains(&folded_line))
-                    || decl.extra_usage().to_folded_case().contains(&folded_line))
+                    || sig.extra_usage.to_folded_case().contains(&folded_line)
-                .then_some(decl)
             })
             .collect::<Vec<_>>();
 
-        commands.sort_by_cached_key(|decl| levenshtein_distance(line, decl.name()));
+        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)
+        });
 
         commands
             .into_iter()
-            .map(|decl| {
+            .map(|(sig, examples, _, _, _)| {
                 let mut long_desc = String::new();
 
-                let usage = decl.usage();
+                let usage = &sig.usage;
                 if !usage.is_empty() {
                     long_desc.push_str(usage);
                     long_desc.push_str("\r\n\r\n");
                 }
 
-                let extra_usage = decl.extra_usage();
+                let extra_usage = &sig.extra_usage;
                 if !extra_usage.is_empty() {
                     long_desc.push_str(extra_usage);
                     long_desc.push_str("\r\n\r\n");
                 }
 
-                let sig = decl.signature();
                 let _ = write!(long_desc, "Usage:\r\n  > {}\r\n", sig.call_signature());
 
                 if !sig.named.is_empty() {
-                    long_desc.push_str(&get_flags_section(Some(&*self.0.clone()), &sig, |v| {
+                    long_desc.push_str(&get_flags_section(Some(&*self.0.clone()), sig, |v| {
                         v.to_parsable_string(", ", &self.0.config)
                     }))
                 }
@@ -92,14 +93,13 @@ impl NuHelpCompleter {
                     }
                 }
 
-                let extra: Vec<String> = decl
+                let extra: Vec<String> = examples
-                    .examples()
                     .iter()
                     .map(|example| example.example.replace('\n', "\r\n"))
                     .collect();
 
                 Suggestion {
-                    value: decl.name().into(),
+                    value: sig.name.clone(),
                     description: Some(long_desc),
                     style: None,
                     extra: Some(extra),

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

@@ -28,7 +28,7 @@ impl NuMenuCompleter {
         Self {
             block_id,
             span,
-            stack: stack.reset_out_dest().capture(),
+            stack: stack.reset_stdio().capture(),
             engine_state,
             only_buffer_difference,
         }
@@ -59,7 +59,8 @@ impl Completer for NuMenuCompleter {
 
         let res = eval_block::<WithoutDebug>(&self.engine_state, &mut self.stack, block, input);
 
-        if let Ok(values) = res.and_then(|data| data.into_value(self.span)) {
+        if let Ok(values) = res {
+            let values = values.into_value(self.span);
             convert_to_suggestions(values, line, pos, self.only_buffer_difference)
         } else {
             Vec::new()

crates/nu-cli/src/prompt.rs

@@ -1,10 +1,4 @@
-use crate::prompt_update::{
+use crate::prompt_update::{POST_PROMPT_MARKER, PRE_PROMPT_MARKER};
-    POST_PROMPT_MARKER, PRE_PROMPT_MARKER, VSCODE_POST_PROMPT_MARKER, VSCODE_PRE_PROMPT_MARKER,
-};
-use nu_protocol::{
-    engine::{EngineState, Stack},
-    Value,
-};
 #[cfg(windows)]
 use nu_utils::enable_vt_processing;
 use reedline::{
@@ -16,8 +10,7 @@ use std::borrow::Cow;
 /// Nushell prompt definition
 #[derive(Clone)]
 pub struct NushellPrompt {
-    shell_integration_osc133: bool,
+    shell_integration: bool,
-    shell_integration_osc633: bool,
     left_prompt_string: Option<String>,
     right_prompt_string: Option<String>,
     default_prompt_indicator: Option<String>,
@@ -25,20 +18,12 @@ pub struct NushellPrompt {
     default_vi_normal_prompt_indicator: Option<String>,
     default_multiline_indicator: Option<String>,
     render_right_prompt_on_last_line: bool,
-    engine_state: EngineState,
-    stack: Stack,
 }
 
 impl NushellPrompt {
-    pub fn new(
+    pub fn new(shell_integration: bool) -> NushellPrompt {
-        shell_integration_osc133: bool,
-        shell_integration_osc633: bool,
-        engine_state: EngineState,
-        stack: Stack,
-    ) -> NushellPrompt {
         NushellPrompt {
-            shell_integration_osc133,
+            shell_integration,
-            shell_integration_osc633,
             left_prompt_string: None,
             right_prompt_string: None,
             default_prompt_indicator: None,
@@ -46,8 +31,6 @@ impl NushellPrompt {
             default_vi_normal_prompt_indicator: None,
             default_multiline_indicator: None,
             render_right_prompt_on_last_line: false,
-            engine_state,
-            stack,
         }
     }
 
@@ -123,19 +106,7 @@ impl Prompt for NushellPrompt {
                 .to_string()
                 .replace('\n', "\r\n");
 
-            if self.shell_integration_osc633 {
+            if self.shell_integration {
-                if self.stack.get_env_var(&self.engine_state, "TERM_PROGRAM")
-                    == Some(Value::test_string("vscode"))
-                {
-                    // We're in vscode and we have osc633 enabled
-                    format!("{VSCODE_PRE_PROMPT_MARKER}{prompt}{VSCODE_POST_PROMPT_MARKER}").into()
-                } else if self.shell_integration_osc133 {
-                    // If we're in VSCode but we don't find the env var, but we have osc133 set, then use it
-                    format!("{PRE_PROMPT_MARKER}{prompt}{POST_PROMPT_MARKER}").into()
-                } else {
-                    prompt.into()
-                }
-            } else if self.shell_integration_osc133 {
                 format!("{PRE_PROMPT_MARKER}{prompt}{POST_PROMPT_MARKER}").into()
             } else {
                 prompt.into()

crates/nu-cli/src/prompt_update.rs

@@ -1,9 +1,9 @@
 use crate::NushellPrompt;
 use log::trace;
-use nu_engine::ClosureEvalOnce;
+use nu_engine::get_eval_subexpression;
 use nu_protocol::{
-    engine::{EngineState, Stack},
+    engine::{EngineState, Stack, StateWorkingSet},
-    report_error_new, Config, PipelineData, Value,
+    report_error, Config, PipelineData, Value,
 };
 use reedline::Prompt;
 
@@ -23,37 +23,10 @@ pub(crate) const TRANSIENT_PROMPT_INDICATOR_VI_NORMAL: &str =
     "TRANSIENT_PROMPT_INDICATOR_VI_NORMAL";
 pub(crate) const TRANSIENT_PROMPT_MULTILINE_INDICATOR: &str =
     "TRANSIENT_PROMPT_MULTILINE_INDICATOR";
-
-// Store all these Ansi Escape Markers here so they can be reused easily
 // According to Daniel Imms @Tyriar, we need to do these this way:
 // <133 A><prompt><133 B><command><133 C><command output>
 pub(crate) const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
 pub(crate) const POST_PROMPT_MARKER: &str = "\x1b]133;B\x1b\\";
-pub(crate) const PRE_EXECUTION_MARKER: &str = "\x1b]133;C\x1b\\";
-#[allow(dead_code)]
-pub(crate) const POST_EXECUTION_MARKER_PREFIX: &str = "\x1b]133;D;";
-#[allow(dead_code)]
-pub(crate) const POST_EXECUTION_MARKER_SUFFIX: &str = "\x1b\\";
-
-// OSC633 is the same as OSC133 but specifically for VSCode
-pub(crate) const VSCODE_PRE_PROMPT_MARKER: &str = "\x1b]633;A\x1b\\";
-pub(crate) const VSCODE_POST_PROMPT_MARKER: &str = "\x1b]633;B\x1b\\";
-#[allow(dead_code)]
-pub(crate) const VSCODE_PRE_EXECUTION_MARKER: &str = "\x1b]633;C\x1b\\";
-#[allow(dead_code)]
-//"\x1b]633;D;{}\x1b\\"
-pub(crate) const VSCODE_POST_EXECUTION_MARKER_PREFIX: &str = "\x1b]633;D;";
-#[allow(dead_code)]
-pub(crate) const VSCODE_POST_EXECUTION_MARKER_SUFFIX: &str = "\x1b\\";
-#[allow(dead_code)]
-pub(crate) const VSCODE_COMMANDLINE_MARKER: &str = "\x1b]633;E\x1b\\";
-#[allow(dead_code)]
-// "\x1b]633;P;Cwd={}\x1b\\"
-pub(crate) const VSCODE_CWD_PROPERTY_MARKER_PREFIX: &str = "\x1b]633;P;Cwd=";
-#[allow(dead_code)]
-pub(crate) const VSCODE_CWD_PROPERTY_MARKER_SUFFIX: &str = "\x1b\\";
-
-pub(crate) const RESET_APPLICATION_MODE: &str = "\x1b[?1l";
 
 fn get_prompt_string(
     prompt: &str,
@@ -61,13 +34,17 @@ fn get_prompt_string(
     engine_state: &EngineState,
     stack: &mut Stack,
 ) -> Option<String> {
+    let eval_subexpression = get_eval_subexpression(engine_state);
+
     stack
         .get_env_var(engine_state, prompt)
         .and_then(|v| match v {
             Value::Closure { val, .. } => {
-                let result = ClosureEvalOnce::new(engine_state, stack, *val)
+                let block = engine_state.get_block(val.block_id);
-                    .run_with_input(PipelineData::Empty);
+                let mut stack = stack.captures_to_stack(val.captures);
-
+                // Use eval_subexpression to force a redirection of output, so we can use everything in prompt
+                let ret_val =
+                    eval_subexpression(engine_state, &mut stack, block, PipelineData::empty());
                 trace!(
                     "get_prompt_string (block) {}:{}:{}",
                     file!(),
@@ -75,9 +52,28 @@ fn get_prompt_string(
                     column!()
                 );
 
-                result
+                ret_val
                     .map_err(|err| {
-                        report_error_new(engine_state, &err);
+                        let working_set = StateWorkingSet::new(engine_state);
+                        report_error(&working_set, &err);
+                    })
+                    .ok()
+            }
+            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::empty());
+                trace!(
+                    "get_prompt_string (block) {}:{}:{}",
+                    file!(),
+                    line!(),
+                    column!()
+                );
+
+                ret_val
+                    .map_err(|err| {
+                        let working_set = StateWorkingSet::new(engine_state);
+                        report_error(&working_set, &err);
                     })
                     .ok()
             }
@@ -107,34 +103,20 @@ pub(crate) fn update_prompt(
     stack: &mut Stack,
     nu_prompt: &mut NushellPrompt,
 ) {
-    let configured_left_prompt_string =
+    let left_prompt_string = get_prompt_string(PROMPT_COMMAND, config, engine_state, stack);
-        match get_prompt_string(PROMPT_COMMAND, config, engine_state, stack) {
-            Some(s) => s,
-            None => "".to_string(),
-        };
 
     // 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_osc633 {
+    let left_prompt_string = if config.shell_integration {
-        if stack.get_env_var(engine_state, "TERM_PROGRAM") == Some(Value::test_string("vscode")) {
+        if let Some(prompt_string) = left_prompt_string {
-            // We're in vscode and we have osc633 enabled
             Some(format!(
-                "{VSCODE_PRE_PROMPT_MARKER}{configured_left_prompt_string}{VSCODE_POST_PROMPT_MARKER}"
+                "{PRE_PROMPT_MARKER}{prompt_string}{POST_PROMPT_MARKER}"
-            ))
-        } else if config.shell_integration_osc133 {
-            // If we're in VSCode but we don't find the env var, but we have osc133 set, then use it
-            Some(format!(
-                "{PRE_PROMPT_MARKER}{configured_left_prompt_string}{POST_PROMPT_MARKER}"
             ))
         } else {
-            configured_left_prompt_string.into()
+            left_prompt_string
         }
-    } else if config.shell_integration_osc133 {
-        Some(format!(
-            "{PRE_PROMPT_MARKER}{configured_left_prompt_string}{POST_PROMPT_MARKER}"
-        ))
     } else {
-        configured_left_prompt_string.into()
+        left_prompt_string
     };
 
     let right_prompt_string = get_prompt_string(PROMPT_COMMAND_RIGHT, config, engine_state, stack);

crates/nu-cli/src/reedline_config.rs

@@ -1,7 +1,6 @@
 use crate::{menus::NuMenuCompleter, NuHelpCompleter};
 use crossterm::event::{KeyCode, KeyModifiers};
 use log::trace;
-use nu_ansi_term::Style;
 use nu_color_config::{color_record_to_nustyle, lookup_ansi_color_style};
 use nu_engine::eval_block;
 use nu_parser::parse;
@@ -159,14 +158,21 @@ fn add_menu(
     }
 }
 
-fn get_style(record: &Record, name: &str, span: Span) -> Option<Style> {
+macro_rules! add_style {
-    extract_value(name, record, span)
+    // first arm match add!(1,2), add!(2,3) etc
-        .ok()
+    ($name:expr, $record: expr, $span:expr, $config: expr, $menu:expr, $f:expr) => {
-        .map(|text| match text {
+        $menu = match extract_value($name, $record, $span) {
-            Value::String { val, .. } => lookup_ansi_color_style(val),
+            Ok(text) => {
-            Value::Record { .. } => color_record_to_nustyle(text),
+                let style = match text {
-            _ => lookup_ansi_color_style("green"),
+                    Value::String { val, .. } => lookup_ansi_color_style(&val),
-        })
+                    Value::Record { .. } => color_record_to_nustyle(&text),
+                    _ => lookup_ansi_color_style("green"),
+                };
+                $f($menu, style)
+            }
+            Err(_) => $menu,
+        };
+    };
 }
 
 // Adds a columnar menu to the editor engine
@@ -209,21 +215,46 @@ pub(crate) fn add_columnar_menu(
 
     let span = menu.style.span();
     if let Value::Record { val, .. } = &menu.style {
-        if let Some(style) = get_style(val, "text", span) {
+        add_style!(
-            columnar_menu = columnar_menu.with_text_style(style);
+            "text",
-        }
+            val,
-        if let Some(style) = get_style(val, "selected_text", span) {
+            span,
-            columnar_menu = columnar_menu.with_selected_text_style(style);
+            config,
-        }
+            columnar_menu,
-        if let Some(style) = get_style(val, "description_text", span) {
+            ColumnarMenu::with_text_style
-            columnar_menu = columnar_menu.with_description_text_style(style);
+        );
-        }
+        add_style!(
-        if let Some(style) = get_style(val, "match_text", span) {
+            "selected_text",
-            columnar_menu = columnar_menu.with_match_text_style(style);
+            val,
-        }
+            span,
-        if let Some(style) = get_style(val, "selected_match_text", span) {
+            config,
-            columnar_menu = columnar_menu.with_selected_match_text_style(style);
+            columnar_menu,
-        }
+            ColumnarMenu::with_selected_text_style
+        );
+        add_style!(
+            "description_text",
+            val,
+            span,
+            config,
+            columnar_menu,
+            ColumnarMenu::with_description_text_style
+        );
+        add_style!(
+            "match_text",
+            val,
+            span,
+            config,
+            columnar_menu,
+            ColumnarMenu::with_match_text_style
+        );
+        add_style!(
+            "selected_match_text",
+            val,
+            span,
+            config,
+            columnar_menu,
+            ColumnarMenu::with_selected_match_text_style
+        );
     }
 
     let marker = menu.marker.to_expanded_string("", config);
@@ -282,15 +313,30 @@ pub(crate) fn add_list_menu(
 
     let span = menu.style.span();
     if let Value::Record { val, .. } = &menu.style {
-        if let Some(style) = get_style(val, "text", span) {
+        add_style!(
-            list_menu = list_menu.with_text_style(style);
+            "text",
-        }
+            val,
-        if let Some(style) = get_style(val, "selected_text", span) {
+            span,
-            list_menu = list_menu.with_selected_text_style(style);
+            config,
-        }
+            list_menu,
-        if let Some(style) = get_style(val, "description_text", span) {
+            ListMenu::with_text_style
-            list_menu = list_menu.with_description_text_style(style);
+        );
-        }
+        add_style!(
+            "selected_text",
+            val,
+            span,
+            config,
+            list_menu,
+            ListMenu::with_selected_text_style
+        );
+        add_style!(
+            "description_text",
+            val,
+            span,
+            config,
+            list_menu,
+            ListMenu::with_description_text_style
+        );
     }
 
     let marker = menu.marker.to_expanded_string("", config);
@@ -474,21 +520,46 @@ pub(crate) fn add_ide_menu(
 
     let span = menu.style.span();
     if let Value::Record { val, .. } = &menu.style {
-        if let Some(style) = get_style(val, "text", span) {
+        add_style!(
-            ide_menu = ide_menu.with_text_style(style);
+            "text",
-        }
+            val,
-        if let Some(style) = get_style(val, "selected_text", span) {
+            span,
-            ide_menu = ide_menu.with_selected_text_style(style);
+            config,
-        }
+            ide_menu,
-        if let Some(style) = get_style(val, "description_text", span) {
+            IdeMenu::with_text_style
-            ide_menu = ide_menu.with_description_text_style(style);
+        );
-        }
+        add_style!(
-        if let Some(style) = get_style(val, "match_text", span) {
+            "selected_text",
-            ide_menu = ide_menu.with_match_text_style(style);
+            val,
-        }
+            span,
-        if let Some(style) = get_style(val, "selected_match_text", span) {
+            config,
-            ide_menu = ide_menu.with_selected_match_text_style(style);
+            ide_menu,
-        }
+            IdeMenu::with_selected_text_style
+        );
+        add_style!(
+            "description_text",
+            val,
+            span,
+            config,
+            ide_menu,
+            IdeMenu::with_description_text_style
+        );
+        add_style!(
+            "match_text",
+            val,
+            span,
+            config,
+            ide_menu,
+            IdeMenu::with_match_text_style
+        );
+        add_style!(
+            "selected_match_text",
+            val,
+            span,
+            config,
+            ide_menu,
+            IdeMenu::with_selected_match_text_style
+        );
     }
 
     let marker = menu.marker.to_expanded_string("", config);
@@ -579,15 +650,30 @@ pub(crate) fn add_description_menu(
 
     let span = menu.style.span();
     if let Value::Record { val, .. } = &menu.style {
-        if let Some(style) = get_style(val, "text", span) {
+        add_style!(
-            description_menu = description_menu.with_text_style(style);
+            "text",
-        }
+            val,
-        if let Some(style) = get_style(val, "selected_text", span) {
+            span,
-            description_menu = description_menu.with_selected_text_style(style);
+            config,
-        }
+            description_menu,
-        if let Some(style) = get_style(val, "description_text", span) {
+            DescriptionMenu::with_text_style
-            description_menu = description_menu.with_description_text_style(style);
+        );
-        }
+        add_style!(
+            "selected_text",
+            val,
+            span,
+            config,
+            description_menu,
+            DescriptionMenu::with_selected_text_style
+        );
+        add_style!(
+            "description_text",
+            val,
+            span,
+            config,
+            description_menu,
+            DescriptionMenu::with_description_text_style
+        );
     }
 
     let marker = menu.marker.to_expanded_string("", config);

crates/nu-cli/src/repl.rs

@@ -1,9 +1,3 @@
-use crate::prompt_update::{
-    POST_EXECUTION_MARKER_PREFIX, POST_EXECUTION_MARKER_SUFFIX, PRE_EXECUTION_MARKER,
-    RESET_APPLICATION_MODE, VSCODE_CWD_PROPERTY_MARKER_PREFIX, VSCODE_CWD_PROPERTY_MARKER_SUFFIX,
-    VSCODE_POST_EXECUTION_MARKER_PREFIX, VSCODE_POST_EXECUTION_MARKER_SUFFIX,
-    VSCODE_PRE_EXECUTION_MARKER,
-};
 use crate::{
     completions::NuCompleter,
     nu_highlight::NoOpHighlighter,
@@ -20,19 +14,16 @@ use nu_cmd_base::{
     util::{get_editor, get_guaranteed_cwd},
 };
 use nu_color_config::StyleComputer;
-#[allow(deprecated)]
+use nu_engine::{convert_env_values, env_to_strings};
-use nu_engine::{convert_env_values, current_dir_str, env_to_strings};
 use nu_parser::{lex, parse, trim_quotes_str};
 use nu_protocol::{
     config::NuCursorShape,
     engine::{EngineState, Stack, StateWorkingSet},
+    eval_const::create_nu_constant,
     report_error_new, HistoryConfig, HistoryFileFormat, PipelineData, ShellError, Span, Spanned,
-    Value,
+    Value, NU_VARIABLE_ID,
-};
-use nu_utils::{
-    filesystem::{have_permission, PermissionResult},
-    utils::perf,
 };
+use nu_utils::utils::perf;
 use reedline::{
     CursorConfig, CwdAwareHinter, DefaultCompleter, EditCommand, Emacs, FileBackedHistory,
     HistorySessionId, Reedline, SqliteBackedHistory, Vi,
@@ -48,6 +39,16 @@ use std::{
 };
 use sysinfo::System;
 
+// According to Daniel Imms @Tyriar, we need to do these this way:
+// <133 A><prompt><133 B><command><133 C><command output>
+// These first two have been moved to prompt_update to get as close as possible to the prompt.
+// const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
+// const POST_PROMPT_MARKER: &str = "\x1b]133;B\x1b\\";
+const PRE_EXECUTE_MARKER: &str = "\x1b]133;C\x1b\\";
+// This one is in get_command_finished_marker() now so we can capture the exit codes properly.
+// const CMD_FINISHED_MARKER: &str = "\x1b]133;D;{}\x1b\\";
+const RESET_APPLICATION_MODE: &str = "\x1b[?1l";
+
 /// The main REPL loop, including spinning up the prompt itself.
 pub fn evaluate_repl(
     engine_state: &mut EngineState,
@@ -62,7 +63,7 @@ pub fn evaluate_repl(
     // so that it may be read by various reedline plugins. During this, we
     // can't modify the stack, but at the end of the loop we take back ownership
     // from the Arc. This lets us avoid copying stack variables needlessly
-    let mut unique_stack = stack.clone();
+    let mut unique_stack = stack;
     let config = engine_state.get_config();
     let use_color = config.use_ansi_coloring;
 
@@ -70,23 +71,11 @@ pub fn evaluate_repl(
 
     let mut entry_num = 0;
 
-    // Let's grab the shell_integration configs
+    let nu_prompt = NushellPrompt::new(config.shell_integration);
-    let shell_integration_osc2 = config.shell_integration_osc2;
-    let shell_integration_osc7 = config.shell_integration_osc7;
-    let shell_integration_osc9_9 = config.shell_integration_osc9_9;
-    let shell_integration_osc133 = config.shell_integration_osc133;
-    let shell_integration_osc633 = config.shell_integration_osc633;
-
-    let nu_prompt = NushellPrompt::new(
-        shell_integration_osc133,
-        shell_integration_osc633,
-        engine_state.clone(),
-        stack.clone(),
-    );
 
     let start_time = std::time::Instant::now();
     // Translate environment variables from Strings to Values
-    if let Err(e) = convert_env_values(engine_state, &unique_stack) {
+    if let Some(e) = convert_env_values(engine_state, &unique_stack) {
         report_error_new(engine_state, &e);
     }
     perf(
@@ -122,29 +111,11 @@ pub fn evaluate_repl(
         engine_state.merge_env(&mut unique_stack, cwd)?;
     }
 
-    let hostname = System::host_name();
-    if shell_integration_osc2 {
-        run_shell_integration_osc2(None, engine_state, &mut unique_stack, use_color);
-    }
-    if shell_integration_osc7 {
-        run_shell_integration_osc7(
-            hostname.as_deref(),
-            engine_state,
-            &mut unique_stack,
-            use_color,
-        );
-    }
-    if shell_integration_osc9_9 {
-        run_shell_integration_osc9_9(engine_state, &mut unique_stack, use_color);
-    }
-    if shell_integration_osc633 {
-        run_shell_integration_osc633(engine_state, &mut unique_stack, use_color);
-    }
-
     engine_state.set_startup_time(entire_start_time.elapsed().as_nanos() as i64);
 
     // Regenerate the $nu constant to contain the startup time and any other potential updates
-    engine_state.generate_nu_constant();
+    let nu_const = create_nu_constant(engine_state, Span::unknown())?;
+    engine_state.set_variable_const_val(NU_VARIABLE_ID, nu_const);
 
     if load_std_lib.is_none() && engine_state.get_config().show_banner {
         eval_source(
@@ -173,7 +144,7 @@ pub fn evaluate_repl(
         let temp_file_cloned = temp_file.clone();
         let mut nu_prompt_cloned = nu_prompt.clone();
 
-        let iteration_panic_state = catch_unwind(AssertUnwindSafe(|| {
+        let iteration_panic_state = catch_unwind(AssertUnwindSafe(move || {
             let (continue_loop, current_stack, line_editor) = loop_iteration(LoopContext {
                 engine_state: &mut current_engine_state,
                 stack: current_stack,
@@ -182,7 +153,6 @@ pub fn evaluate_repl(
                 temp_file: &temp_file_cloned,
                 use_color,
                 entry_num: &mut entry_num,
-                hostname: hostname.as_deref(),
             });
 
             // pass the most recent version of the line_editor back
@@ -259,7 +229,6 @@ struct LoopContext<'a> {
     temp_file: &'a Path,
     use_color: bool,
     entry_num: &'a mut usize,
-    hostname: Option<&'a str>,
 }
 
 /// Perform one iteration of the REPL loop
@@ -278,7 +247,6 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
         temp_file,
         use_color,
         entry_num,
-        hostname,
     } = ctx;
 
     let cwd = get_guaranteed_cwd(engine_state, &stack);
@@ -387,13 +355,12 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
         .with_completer(Box::new(NuCompleter::new(
             engine_reference.clone(),
             // STACK-REFERENCE 2
-            stack_arc.clone(),
+            Stack::with_parent(stack_arc.clone()),
         )))
         .with_quick_completions(config.quick_completions)
         .with_partial_completions(config.partial_completions)
         .with_ansi_colors(config.use_ansi_coloring)
         .with_cursor_config(cursor_config);
-
     perf(
         "reedline builder",
         start_time,
@@ -415,7 +382,6 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
     } else {
         line_editor.disable_hints()
     };
-
     perf(
         "reedline coloring/style_computer",
         start_time,
@@ -432,9 +398,8 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
             report_error_new(engine_state, &e);
             Reedline::create()
         });
-
     perf(
-        "reedline adding menus",
+        "reedline menus",
         start_time,
         file!(),
         line!(),
@@ -456,7 +421,6 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
     } else {
         line_editor
     };
-
     perf(
         "reedline buffer_editor",
         start_time,
@@ -473,7 +437,6 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
                 warn!("Failed to sync history: {}", e);
             }
         }
-
         perf(
             "sync_history",
             start_time,
@@ -487,7 +450,6 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
     start_time = std::time::Instant::now();
     // Changing the line editor based on the found keybindings
     line_editor = setup_keybindings(engine_state, line_editor);
-
     perf(
         "keybindings",
         start_time,
@@ -511,7 +473,6 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
         &mut Stack::with_parent(stack_arc.clone()),
         nu_prompt,
     );
-
     perf(
         "update_prompt",
         start_time,
@@ -533,43 +494,22 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
         .with_highlighter(Box::<NoOpHighlighter>::default())
         // CLEAR STACK-REFERENCE 2
         .with_completer(Box::<DefaultCompleter>::default());
+    let shell_integration = config.shell_integration;
 
-    // Let's grab the shell_integration configs
+    let mut stack = Stack::unwrap_unique(stack_arc);
-    let shell_integration_osc2 = config.shell_integration_osc2;
-    let shell_integration_osc7 = config.shell_integration_osc7;
-    let shell_integration_osc9_9 = config.shell_integration_osc9_9;
-    let shell_integration_osc133 = config.shell_integration_osc133;
-    let shell_integration_osc633 = config.shell_integration_osc633;
-    let shell_integration_reset_application_mode = config.shell_integration_reset_application_mode;
 
-    // TODO: we may clone the stack, this can lead to major performance issues
-    // so we should avoid it or making stack cheaper to clone.
-    let mut stack = Arc::unwrap_or_clone(stack_arc);
-
-    perf(
-        "line_editor setup",
-        start_time,
-        file!(),
-        line!(),
-        column!(),
-        use_color,
-    );
-
-    let line_editor_input_time = std::time::Instant::now();
     match input {
         Ok(Signal::Success(s)) => {
+            let hostname = System::host_name();
             let history_supports_meta = matches!(
                 engine_state.history_config().map(|h| h.file_format),
                 Some(HistoryFileFormat::Sqlite)
             );
 
             if history_supports_meta {
-                prepare_history_metadata(&s, hostname, engine_state, &mut line_editor);
+                prepare_history_metadata(&s, &hostname, engine_state, &mut line_editor);
             }
 
-            // For pre_exec_hook
-            start_time = Instant::now();
-
             // Right before we start running the code the user gave us, fire the `pre_execution`
             // hook
             if let Some(hook) = config.hooks.pre_execution.clone() {
@@ -590,80 +530,22 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
                 }
             }
 
-            perf(
-                "pre_execution_hook",
-                start_time,
-                file!(),
-                line!(),
-                column!(),
-                use_color,
-            );
-
             let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
             repl.cursor_pos = line_editor.current_insertion_point();
             repl.buffer = line_editor.current_buffer_contents().to_string();
             drop(repl);
 
-            if shell_integration_osc633 {
+            if shell_integration {
-                if stack.get_env_var(engine_state, "TERM_PROGRAM")
+                run_ansi_sequence(PRE_EXECUTE_MARKER);
-                    == Some(Value::test_string("vscode"))
-                {
-                    start_time = Instant::now();
-
-                    run_ansi_sequence(VSCODE_PRE_EXECUTION_MARKER);
-
-                    perf(
-                        "pre_execute_marker (633;C) ansi escape sequence",
-                        start_time,
-                        file!(),
-                        line!(),
-                        column!(),
-                        use_color,
-                    );
-                } else if shell_integration_osc133 {
-                    start_time = Instant::now();
-
-                    run_ansi_sequence(PRE_EXECUTION_MARKER);
-
-                    perf(
-                        "pre_execute_marker (133;C) ansi escape sequence",
-                        start_time,
-                        file!(),
-                        line!(),
-                        column!(),
-                        use_color,
-                    );
-                }
-            } else if shell_integration_osc133 {
-                start_time = Instant::now();
-
-                run_ansi_sequence(PRE_EXECUTION_MARKER);
-
-                perf(
-                    "pre_execute_marker (133;C) ansi escape sequence",
-                    start_time,
-                    file!(),
-                    line!(),
-                    column!(),
-                    use_color,
-                );
             }
 
             // Actual command execution logic starts from here
-            let cmd_execution_start_time = Instant::now();
+            let start_time = Instant::now();
 
             match parse_operation(s.clone(), engine_state, &stack) {
                 Ok(operation) => match operation {
                     ReplOperation::AutoCd { cwd, target, span } => {
                         do_auto_cd(target, cwd, &mut stack, engine_state, span);
-
-                        run_finaliziation_ansi_sequence(
-                            &stack,
-                            engine_state,
-                            use_color,
-                            shell_integration_osc633,
-                            shell_integration_osc133,
-                        );
                     }
                     ReplOperation::RunCommand(cmd) => {
                         line_editor = do_run_cmd(
@@ -671,25 +553,16 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
                             &mut stack,
                             engine_state,
                             line_editor,
-                            shell_integration_osc2,
+                            shell_integration,
                             *entry_num,
-                            use_color,
+                        )
-                        );
-
-                        run_finaliziation_ansi_sequence(
-                            &stack,
-                            engine_state,
-                            use_color,
-                            shell_integration_osc633,
-                            shell_integration_osc133,
-                        );
                     }
                     // as the name implies, we do nothing in this case
                     ReplOperation::DoNothing => {}
                 },
                 Err(ref e) => error!("Error parsing operation: {e}"),
             }
-            let cmd_duration = cmd_execution_start_time.elapsed();
+            let cmd_duration = start_time.elapsed();
 
             stack.add_env_var(
                 "CMD_DURATION_MS".into(),
@@ -708,45 +581,23 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
                 }
             }
 
-            if shell_integration_osc2 {
+            if shell_integration {
-                run_shell_integration_osc2(None, engine_state, &mut stack, use_color);
+                do_shell_integration_finalize_command(hostname, engine_state, &mut stack);
-            }
-            if shell_integration_osc7 {
-                run_shell_integration_osc7(hostname, engine_state, &mut stack, use_color);
-            }
-            if shell_integration_osc9_9 {
-                run_shell_integration_osc9_9(engine_state, &mut stack, use_color);
-            }
-            if shell_integration_osc633 {
-                run_shell_integration_osc633(engine_state, &mut stack, use_color);
-            }
-            if shell_integration_reset_application_mode {
-                run_shell_integration_reset_application_mode();
             }
 
             flush_engine_state_repl_buffer(engine_state, &mut line_editor);
         }
         Ok(Signal::CtrlC) => {
             // `Reedline` clears the line content. New prompt is shown
-            run_finaliziation_ansi_sequence(
+            if shell_integration {
-                &stack,
+                run_ansi_sequence(&get_command_finished_marker(&stack, engine_state));
-                engine_state,
+            }
-                use_color,
-                shell_integration_osc633,
-                shell_integration_osc133,
-            );
         }
         Ok(Signal::CtrlD) => {
             // When exiting clear to a new line
-
+            if shell_integration {
-            run_finaliziation_ansi_sequence(
+                run_ansi_sequence(&get_command_finished_marker(&stack, engine_state));
-                &stack,
+            }
-                engine_state,
-                use_color,
-                shell_integration_osc633,
-                shell_integration_osc133,
-            );
-
             println!();
             return (false, stack, line_editor);
         }
@@ -759,19 +610,14 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
                 // e.g. https://github.com/nushell/nushell/issues/6452
                 // Alternatively only allow that expected failures let the REPL loop
             }
-
+            if shell_integration {
-            run_finaliziation_ansi_sequence(
+                run_ansi_sequence(&get_command_finished_marker(&stack, engine_state));
-                &stack,
+            }
-                engine_state,
-                use_color,
-                shell_integration_osc633,
-                shell_integration_osc133,
-            );
         }
     }
     perf(
         "processing line editor input",
-        line_editor_input_time,
+        start_time,
         file!(),
         line!(),
         column!(),
@@ -779,7 +625,7 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
     );
 
     perf(
-        "time between prompts in line editor loop",
+        "finished repl loop",
         loop_start_time,
         file!(),
         line!(),
@@ -795,16 +641,15 @@ fn loop_iteration(ctx: LoopContext) -> (bool, Stack, Reedline) {
 ///
 fn prepare_history_metadata(
     s: &str,
-    hostname: Option<&str>,
+    hostname: &Option<String>,
     engine_state: &EngineState,
     line_editor: &mut Reedline,
 ) {
     if !s.is_empty() && line_editor.has_last_command_context() {
-        #[allow(deprecated)]
         let result = line_editor
             .update_last_command_context(&|mut c| {
                 c.start_timestamp = Some(chrono::Utc::now());
-                c.hostname = hostname.map(str::to_string);
+                c.hostname.clone_from(hostname);
 
                 c.cwd = Some(StateWorkingSet::new(engine_state).get_cwd());
                 c
@@ -871,8 +716,7 @@ fn parse_operation(
 ) -> Result<ReplOperation, ErrReport> {
     let tokens = lex(s.as_bytes(), 0, &[], &[], false);
     // Check if this is a single call to a directory, if so auto-cd
-    #[allow(deprecated)]
+    let cwd = nu_engine::env::current_dir_str(engine_state, stack)?;
-    let cwd = nu_engine::env::current_dir_str(engine_state, stack).unwrap_or_default();
     let mut orig = s.clone();
     if orig.starts_with('`') {
         orig = trim_quotes_str(&orig).to_string()
@@ -912,27 +756,16 @@ fn do_auto_cd(
                 },
             );
         }
+        let path = nu_path::canonicalize_with(path, &cwd)
+            .expect("internal error: cannot canonicalize known path");
         path.to_string_lossy().to_string()
     };
 
-    if let PermissionResult::PermissionDenied(reason) = have_permission(path.clone()) {
-        report_error_new(
-            engine_state,
-            &ShellError::IOError {
-                msg: format!("Cannot change directory to {path}: {reason}"),
-            },
-        );
-        return;
-    }
-
     stack.add_env_var("OLDPWD".into(), Value::string(cwd.clone(), Span::unknown()));
 
     //FIXME: this only changes the current scope, but instead this environment variable
     //should probably be a block that loads the information from the state in the overlay
-    if let Err(err) = stack.set_cwd(&path) {
+    stack.add_env_var("PWD".into(), Value::string(path.clone(), Span::unknown()));
-        report_error_new(engine_state, &err);
-        return;
-    };
     let cwd = Value::string(cwd, span);
 
     let shells = stack.get_env_var(engine_state, "NUSHELL_SHELLS");
@@ -977,9 +810,8 @@ fn do_run_cmd(
     // we pass in the line editor so it can be dropped in the case of a process exit
     // (in the normal case we don't want to drop it so return it as-is otherwise)
     line_editor: Reedline,
-    shell_integration_osc2: bool,
+    shell_integration: bool,
     entry_num: usize,
-    use_color: bool,
 ) -> Reedline {
     trace!("eval source: {}", s);
 
@@ -1004,8 +836,29 @@ fn do_run_cmd(
         }
     }
 
-    if shell_integration_osc2 {
+    if shell_integration {
-        run_shell_integration_osc2(Some(s), engine_state, stack, use_color);
+        if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
+            match cwd.coerce_into_string() {
+                Ok(path) => {
+                    // Try to abbreviate string for windows title
+                    let maybe_abbrev_path = if let Some(p) = nu_path::home_dir() {
+                        path.replace(&p.as_path().display().to_string(), "~")
+                    } else {
+                        path
+                    };
+                    let binary_name = s.split_whitespace().next();
+
+                    if let Some(binary_name) = binary_name {
+                        run_ansi_sequence(&format!(
+                            "\x1b]2;{maybe_abbrev_path}> {binary_name}\x07"
+                        ));
+                    }
+                }
+                Err(e) => {
+                    warn!("Could not coerce working directory to string {e}");
+                }
+            }
+        }
     }
 
     eval_source(
@@ -1022,139 +875,57 @@ fn do_run_cmd(
 
 ///
 /// Output some things and set environment variables so shells with the right integration
-/// can have more information about what is going on (both on startup and after we have
+/// can have more information about what is going on (after we have run a command)
-/// run a command)
 ///
-fn run_shell_integration_osc2(
+fn do_shell_integration_finalize_command(
-    command_name: Option<&str>,
+    hostname: Option<String>,
     engine_state: &EngineState,
     stack: &mut Stack,
-    use_color: bool,
 ) {
-    #[allow(deprecated)]
+    run_ansi_sequence(&get_command_finished_marker(stack, engine_state));
-    if let Ok(path) = current_dir_str(engine_state, stack) {
+    if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
-        let start_time = Instant::now();
+        match cwd.coerce_into_string() {
-
+            Ok(path) => {
-        // Try to abbreviate string for windows title
+                // Supported escape sequences of Microsoft's Visual Studio Code (vscode)
-        let maybe_abbrev_path = if let Some(p) = nu_path::home_dir() {
+                // https://code.visualstudio.com/docs/terminal/shell-integration#_supported-escape-sequences
-            path.replace(&p.as_path().display().to_string(), "~")
+                if stack.get_env_var(engine_state, "TERM_PROGRAM")
-        } else {
+                    == Some(Value::test_string("vscode"))
-            path
+                {
-        };
+                    // If we're in vscode, run their specific ansi escape sequence.
-
+                    // This is helpful for ctrl+g to change directories in the terminal.
-        let title = match command_name {
+                    run_ansi_sequence(&format!("\x1b]633;P;Cwd={}\x1b\\", path));
-            Some(binary_name) => {
-                let split_binary_name = binary_name.split_whitespace().next();
-                if let Some(binary_name) = split_binary_name {
-                    format!("{maybe_abbrev_path}> {binary_name}")
                 } else {
-                    maybe_abbrev_path.to_string()
+                    // Otherwise, communicate the path as OSC 7 (often used for spawning new tabs in the same dir)
+                    run_ansi_sequence(&format!(
+                        "\x1b]7;file://{}{}{}\x1b\\",
+                        percent_encoding::utf8_percent_encode(
+                            &hostname.unwrap_or_else(|| "localhost".to_string()),
+                            percent_encoding::CONTROLS
+                        ),
+                        if path.starts_with('/') { "" } else { "/" },
+                        percent_encoding::utf8_percent_encode(&path, percent_encoding::CONTROLS)
+                    ));
                 }
+
+                // Try to abbreviate string for windows title
+                let maybe_abbrev_path = if let Some(p) = nu_path::home_dir() {
+                    path.replace(&p.as_path().display().to_string(), "~")
+                } else {
+                    path
+                };
+
+                // Set window title too
+                // https://tldp.org/HOWTO/Xterm-Title-3.html
+                // ESC]0;stringBEL -- Set icon name and window title to string
+                // ESC]1;stringBEL -- Set icon name to string
+                // ESC]2;stringBEL -- Set window title to string
+                run_ansi_sequence(&format!("\x1b]2;{maybe_abbrev_path}\x07"));
+            }
+            Err(e) => {
+                warn!("Could not coerce working directory to string {e}");
             }
-            None => maybe_abbrev_path.to_string(),
-        };
-
-        // Set window title too
-        // https://tldp.org/HOWTO/Xterm-Title-3.html
-        // ESC]0;stringBEL -- Set icon name and window title to string
-        // ESC]1;stringBEL -- Set icon name to string
-        // ESC]2;stringBEL -- Set window title to string
-        run_ansi_sequence(&format!("\x1b]2;{title}\x07"));
-
-        perf(
-            "set title with command osc2",
-            start_time,
-            file!(),
-            line!(),
-            column!(),
-            use_color,
-        );
-    }
-}
-
-fn run_shell_integration_osc7(
-    hostname: Option<&str>,
-    engine_state: &EngineState,
-    stack: &mut Stack,
-    use_color: bool,
-) {
-    #[allow(deprecated)]
-    if let Ok(path) = current_dir_str(engine_state, stack) {
-        let start_time = Instant::now();
-
-        // Otherwise, communicate the path as OSC 7 (often used for spawning new tabs in the same dir)
-        run_ansi_sequence(&format!(
-            "\x1b]7;file://{}{}{}\x1b\\",
-            percent_encoding::utf8_percent_encode(
-                hostname.unwrap_or("localhost"),
-                percent_encoding::CONTROLS
-            ),
-            if path.starts_with('/') { "" } else { "/" },
-            percent_encoding::utf8_percent_encode(&path, percent_encoding::CONTROLS)
-        ));
-
-        perf(
-            "communicate path to terminal with osc7",
-            start_time,
-            file!(),
-            line!(),
-            column!(),
-            use_color,
-        );
-    }
-}
-
-fn run_shell_integration_osc9_9(engine_state: &EngineState, stack: &mut Stack, use_color: bool) {
-    #[allow(deprecated)]
-    if let Ok(path) = current_dir_str(engine_state, stack) {
-        let start_time = Instant::now();
-
-        // Otherwise, communicate the path as OSC 9;9 from ConEmu (often used for spawning new tabs in the same dir)
-        // This is helpful in Windows Terminal with Duplicate Tab
-        run_ansi_sequence(&format!(
-            "\x1b]9;9;{}\x1b\\",
-            percent_encoding::utf8_percent_encode(&path, percent_encoding::CONTROLS)
-        ));
-
-        perf(
-            "communicate path to terminal with osc9;9",
-            start_time,
-            file!(),
-            line!(),
-            column!(),
-            use_color,
-        );
-    }
-}
-
-fn run_shell_integration_osc633(engine_state: &EngineState, stack: &mut Stack, use_color: bool) {
-    #[allow(deprecated)]
-    if let Ok(path) = current_dir_str(engine_state, stack) {
-        // Supported escape sequences of Microsoft's Visual Studio Code (vscode)
-        // https://code.visualstudio.com/docs/terminal/shell-integration#_supported-escape-sequences
-        if stack.get_env_var(engine_state, "TERM_PROGRAM") == Some(Value::test_string("vscode")) {
-            let start_time = Instant::now();
-
-            // If we're in vscode, run their specific ansi escape sequence.
-            // This is helpful for ctrl+g to change directories in the terminal.
-            run_ansi_sequence(&format!(
-                "{}{}{}",
-                VSCODE_CWD_PROPERTY_MARKER_PREFIX, path, VSCODE_CWD_PROPERTY_MARKER_SUFFIX
-            ));
-
-            perf(
-                "communicate path to terminal with osc633;P",
-                start_time,
-                file!(),
-                line!(),
-                column!(),
-                use_color,
-            );
         }
     }
-}
-
-fn run_shell_integration_reset_application_mode() {
     run_ansi_sequence(RESET_APPLICATION_MODE);
 }
 
@@ -1301,47 +1072,12 @@ fn map_nucursorshape_to_cursorshape(shape: NuCursorShape) -> Option<SetCursorSty
     }
 }
 
-fn get_command_finished_marker(
+fn get_command_finished_marker(stack: &Stack, engine_state: &EngineState) -> String {
-    stack: &Stack,
-    engine_state: &EngineState,
-    shell_integration_osc633: bool,
-    shell_integration_osc133: bool,
-) -> String {
     let exit_code = stack
         .get_env_var(engine_state, "LAST_EXIT_CODE")
         .and_then(|e| e.as_i64().ok());
 
-    if shell_integration_osc633 {
+    format!("\x1b]133;D;{}\x1b\\", exit_code.unwrap_or(0))
-        if stack.get_env_var(engine_state, "TERM_PROGRAM") == Some(Value::test_string("vscode")) {
-            // We're in vscode and we have osc633 enabled
-            format!(
-                "{}{}{}",
-                VSCODE_POST_EXECUTION_MARKER_PREFIX,
-                exit_code.unwrap_or(0),
-                VSCODE_POST_EXECUTION_MARKER_SUFFIX
-            )
-        } else if shell_integration_osc133 {
-            // If we're in VSCode but we don't find the env var, just return the regular markers
-            format!(
-                "{}{}{}",
-                POST_EXECUTION_MARKER_PREFIX,
-                exit_code.unwrap_or(0),
-                POST_EXECUTION_MARKER_SUFFIX
-            )
-        } else {
-            // We're not in vscode, so we don't need to do anything special
-            "\x1b[0m".to_string()
-        }
-    } else if shell_integration_osc133 {
-        format!(
-            "{}{}{}",
-            POST_EXECUTION_MARKER_PREFIX,
-            exit_code.unwrap_or(0),
-            POST_EXECUTION_MARKER_SUFFIX
-        )
-    } else {
-        "\x1b[0m".to_string()
-    }
 }
 
 fn run_ansi_sequence(seq: &str) {
@@ -1352,73 +1088,6 @@ fn run_ansi_sequence(seq: &str) {
     }
 }
 
-fn run_finaliziation_ansi_sequence(
-    stack: &Stack,
-    engine_state: &EngineState,
-    use_color: bool,
-    shell_integration_osc633: bool,
-    shell_integration_osc133: bool,
-) {
-    if shell_integration_osc633 {
-        // Only run osc633 if we are in vscode
-        if stack.get_env_var(engine_state, "TERM_PROGRAM") == Some(Value::test_string("vscode")) {
-            let start_time = Instant::now();
-
-            run_ansi_sequence(&get_command_finished_marker(
-                stack,
-                engine_state,
-                shell_integration_osc633,
-                shell_integration_osc133,
-            ));
-
-            perf(
-                "post_execute_marker (633;D) ansi escape sequences",
-                start_time,
-                file!(),
-                line!(),
-                column!(),
-                use_color,
-            );
-        } else if shell_integration_osc133 {
-            let start_time = Instant::now();
-
-            run_ansi_sequence(&get_command_finished_marker(
-                stack,
-                engine_state,
-                shell_integration_osc633,
-                shell_integration_osc133,
-            ));
-
-            perf(
-                "post_execute_marker (133;D) ansi escape sequences",
-                start_time,
-                file!(),
-                line!(),
-                column!(),
-                use_color,
-            );
-        }
-    } else if shell_integration_osc133 {
-        let start_time = Instant::now();
-
-        run_ansi_sequence(&get_command_finished_marker(
-            stack,
-            engine_state,
-            shell_integration_osc633,
-            shell_integration_osc133,
-        ));
-
-        perf(
-            "post_execute_marker (133;D) ansi escape sequences",
-            start_time,
-            file!(),
-            line!(),
-            column!(),
-            use_color,
-        );
-    }
-}
-
 // Absolute paths with a drive letter, like 'C:', 'D:\', 'E:\foo'
 #[cfg(windows)]
 static DRIVE_PATH_REGEX: once_cell::sync::Lazy<fancy_regex::Regex> =
@@ -1484,136 +1153,3 @@ fn are_session_ids_in_sync() {
         engine_state.history_session_id
     );
 }
-
-#[cfg(test)]
-mod test_auto_cd {
-    use super::{do_auto_cd, parse_operation, ReplOperation};
-    use nu_protocol::engine::{EngineState, Stack};
-    use std::path::Path;
-    use tempfile::tempdir;
-
-    /// Create a symlink. Works on both Unix and Windows.
-    #[cfg(any(unix, windows))]
-    fn symlink(original: impl AsRef<Path>, link: impl AsRef<Path>) -> std::io::Result<()> {
-        #[cfg(unix)]
-        {
-            std::os::unix::fs::symlink(original, link)
-        }
-        #[cfg(windows)]
-        {
-            if original.as_ref().is_dir() {
-                std::os::windows::fs::symlink_dir(original, link)
-            } else {
-                std::os::windows::fs::symlink_file(original, link)
-            }
-        }
-    }
-
-    /// Run one test case on the auto-cd feature. PWD is initially set to
-    /// `before`, and after `input` is parsed and evaluated, PWD should be
-    /// changed to `after`.
-    #[track_caller]
-    fn check(before: impl AsRef<Path>, input: &str, after: impl AsRef<Path>) {
-        // Setup EngineState and Stack.
-        let mut engine_state = EngineState::new();
-        let mut stack = Stack::new();
-        stack.set_cwd(before).unwrap();
-
-        // Parse the input. It must be an auto-cd operation.
-        let op = parse_operation(input.to_string(), &engine_state, &stack).unwrap();
-        let ReplOperation::AutoCd { cwd, target, span } = op else {
-            panic!("'{}' was not parsed into an auto-cd operation", input)
-        };
-
-        // Perform the auto-cd operation.
-        do_auto_cd(target, cwd, &mut stack, &mut engine_state, span);
-        let updated_cwd = engine_state.cwd(Some(&stack)).unwrap();
-
-        // Check that `updated_cwd` and `after` point to the same place. They
-        // don't have to be byte-wise equal (on Windows, the 8.3 filename
-        // conversion messes things up),
-        let updated_cwd = std::fs::canonicalize(updated_cwd).unwrap();
-        let after = std::fs::canonicalize(after).unwrap();
-        assert_eq!(updated_cwd, after);
-    }
-
-    #[test]
-    fn auto_cd_root() {
-        let tempdir = tempdir().unwrap();
-        let root = if cfg!(windows) { r"C:\" } else { "/" };
-        check(&tempdir, root, root);
-    }
-
-    #[test]
-    fn auto_cd_tilde() {
-        let tempdir = tempdir().unwrap();
-        let home = nu_path::home_dir().unwrap();
-        check(&tempdir, "~", home);
-    }
-
-    #[test]
-    fn auto_cd_dot() {
-        let tempdir = tempdir().unwrap();
-        check(&tempdir, ".", &tempdir);
-    }
-
-    #[test]
-    fn auto_cd_double_dot() {
-        let tempdir = tempdir().unwrap();
-        let dir = tempdir.path().join("foo");
-        std::fs::create_dir_all(&dir).unwrap();
-        check(dir, "..", &tempdir);
-    }
-
-    #[test]
-    fn auto_cd_triple_dot() {
-        let tempdir = tempdir().unwrap();
-        let dir = tempdir.path().join("foo").join("bar");
-        std::fs::create_dir_all(&dir).unwrap();
-        check(dir, "...", &tempdir);
-    }
-
-    #[test]
-    fn auto_cd_relative() {
-        let tempdir = tempdir().unwrap();
-        let foo = tempdir.path().join("foo");
-        let bar = tempdir.path().join("bar");
-        std::fs::create_dir_all(&foo).unwrap();
-        std::fs::create_dir_all(&bar).unwrap();
-
-        let input = if cfg!(windows) { r"..\bar" } else { "../bar" };
-        check(foo, input, bar);
-    }
-
-    #[test]
-    fn auto_cd_trailing_slash() {
-        let tempdir = tempdir().unwrap();
-        let dir = tempdir.path().join("foo");
-        std::fs::create_dir_all(&dir).unwrap();
-
-        let input = if cfg!(windows) { r"foo\" } else { "foo/" };
-        check(&tempdir, input, dir);
-    }
-
-    #[test]
-    fn auto_cd_symlink() {
-        let tempdir = tempdir().unwrap();
-        let dir = tempdir.path().join("foo");
-        std::fs::create_dir_all(&dir).unwrap();
-        let link = tempdir.path().join("link");
-        symlink(&dir, &link).unwrap();
-
-        let input = if cfg!(windows) { r".\link" } else { "./link" };
-        check(&tempdir, input, link);
-    }
-
-    #[test]
-    #[should_panic(expected = "was not parsed into an auto-cd operation")]
-    fn auto_cd_nonexistent_directory() {
-        let tempdir = tempdir().unwrap();
-        let dir = tempdir.path().join("foo");
-
-        let input = if cfg!(windows) { r"foo\" } else { "foo/" };
-        check(&tempdir, input, dir);
-    }
-}

crates/nu-cli/src/syntax_highlight.rs

@@ -4,7 +4,7 @@ use nu_color_config::{get_matching_brackets_style, get_shape_color};
 use nu_engine::env;
 use nu_parser::{flatten_block, parse, FlatShape};
 use nu_protocol::{
-    ast::{Block, Expr, Expression, PipelineRedirection, RecordItem},
+    ast::{Argument, Block, Expr, Expression, PipelineRedirection, RecordItem},
     engine::{EngineState, Stack, StateWorkingSet},
     Config, Span,
 };
@@ -37,7 +37,6 @@ impl Highlighter for NuHighlighter {
 
                         let str_word = String::from_utf8_lossy(str_contents).to_string();
                         let paths = env::path_str(&self.engine_state, &self.stack, *span).ok();
-                        #[allow(deprecated)]
                         let res = if let Ok(cwd) =
                             env::current_dir_str(&self.engine_state, &self.stack)
                         {
@@ -87,8 +86,29 @@ impl Highlighter for NuHighlighter {
                 [(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));
+                    });
+                }};
+            }
+
             let mut add_colored_token = |shape: &FlatShape, text: String| {
-                output.push((get_shape_color(shape.as_str(), &self.config), text));
+                output.push((get_shape_color(shape.to_string(), &self.config), text));
             };
 
             match shape.1 {
@@ -108,32 +128,23 @@ impl Highlighter for NuHighlighter {
                 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::RawString => 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
+                FlatShape::List => {
-                | FlatShape::Table
+                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
-                | FlatShape::Record
+                }
-                | FlatShape::Block
+                FlatShape::Table => {
-                | FlatShape::Closure => {
+                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
-                    let span = shape.0;
+                }
-                    let shape = &shape.1;
+                FlatShape::Record => {
-                    let spans = split_span_by_highlight_positions(
+                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
-                        line,
+                }
-                        span,
+
-                        &matching_brackets_pos,
+                FlatShape::Block => {
-                        global_span_offset,
+                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
-                    );
+                }
-                    for (part, highlight) in spans {
+                FlatShape::Closure => {
-                        let start = part.start - span.start;
+                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
-                        let end = part.end - span.start;
-                        let text = next_token[start..end].to_string();
-                        let mut style = get_shape_color(shape.as_str(), &self.config);
-                        if highlight {
-                            style = get_matching_brackets_style(style, &self.config);
-                        }
-                        output.push((style, text));
-                    }
                 }
 
                 FlatShape::Filepath => add_colored_token(&shape.1, next_token),
@@ -299,6 +310,20 @@ fn find_matching_block_end_in_expr(
     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;
@@ -328,7 +353,6 @@ fn find_matching_block_end_in_expr(
             Expr::Directory(_, _) => None,
             Expr::GlobPattern(_, _) => None,
             Expr::String(_) => None,
-            Expr::RawString(_) => None,
             Expr::CellPath(_) => None,
             Expr::ImportPattern(_) => None,
             Expr::Overlay(_) => None,
@@ -336,8 +360,9 @@ fn find_matching_block_end_in_expr(
             Expr::MatchBlock(_) => None,
             Expr::Nothing => None,
             Expr::Garbage => None,
+            Expr::Spread(_) => None,
 
-            Expr::Table(table) => {
+            Expr::Table(hdr, rows) => {
                 if expr_last == global_cursor_offset {
                     // cursor is at table end
                     Some(expr_first)
@@ -346,19 +371,15 @@ fn find_matching_block_end_in_expr(
                     Some(expr_last)
                 } else {
                     // cursor is inside table
-                    table
+                    for inner_expr in hdr {
-                        .columns
+                        find_in_expr_or_continue!(inner_expr);
-                        .iter()
+                    }
-                        .chain(table.rows.iter().flat_map(AsRef::as_ref))
+                    for row in rows {
-                        .find_map(|expr| {
+                        for inner_expr in row {
-                            find_matching_block_end_in_expr(
+                            find_in_expr_or_continue!(inner_expr);
-                                line,
+                        }
-                                working_set,
+                    }
-                                expr,
+                    None
-                                global_span_offset,
-                                global_cursor_offset,
-                            )
-                        })
                 }
             }
 
@@ -371,45 +392,36 @@ fn find_matching_block_end_in_expr(
                     Some(expr_last)
                 } else {
                     // cursor is inside record
-                    exprs.iter().find_map(|expr| match expr {
+                    for expr in exprs {
-                        RecordItem::Pair(k, v) => find_matching_block_end_in_expr(
+                        match expr {
-                            line,
+                            RecordItem::Pair(k, v) => {
-                            working_set,
+                                find_in_expr_or_continue!(k);
-                            k,
+                                find_in_expr_or_continue!(v);
-                            global_span_offset,
+                            }
-                            global_cursor_offset,
+                            RecordItem::Spread(_, record) => {
-                        )
+                                find_in_expr_or_continue!(record);
-                        .or_else(|| {
+                            }
-                            find_matching_block_end_in_expr(
+                        }
-                                line,
+                    }
-                                working_set,
+                    None
-                                v,
-                                global_span_offset,
-                                global_cursor_offset,
-                            )
-                        }),
-                        RecordItem::Spread(_, record) => find_matching_block_end_in_expr(
-                            line,
-                            working_set,
-                            record,
-                            global_span_offset,
-                            global_cursor_offset,
-                        ),
-                    })
                 }
             }
 
-            Expr::Call(call) => call.arguments.iter().find_map(|arg| {
+            Expr::Call(call) => {
-                arg.expr().and_then(|expr| {
+                for arg in &call.arguments {
-                    find_matching_block_end_in_expr(
+                    let opt_expr = match arg {
-                        line,
+                        Argument::Named((_, _, opt_expr)) => opt_expr.as_ref(),
-                        working_set,
+                        Argument::Positional(inner_expr) => Some(inner_expr),
-                        expr,
+                        Argument::Unknown(inner_expr) => Some(inner_expr),
-                        global_span_offset,
+                        Argument::Spread(inner_expr) => Some(inner_expr),
-                        global_cursor_offset,
+                    };
-                    )
+
-                })
+                    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,
@@ -419,15 +431,12 @@ fn find_matching_block_end_in_expr(
                 global_cursor_offset,
             ),
 
-            Expr::BinaryOp(lhs, op, rhs) => [lhs, op, rhs].into_iter().find_map(|expr| {
+            Expr::BinaryOp(lhs, op, rhs) => {
-                find_matching_block_end_in_expr(
+                find_in_expr_or_continue!(lhs);
-                    line,
+                find_in_expr_or_continue!(op);
-                    working_set,
+                find_in_expr_or_continue!(rhs);
-                    expr,
+                None
-                    global_span_offset,
+            }
-                    global_cursor_offset,
-                )
-            }),
 
             Expr::Block(block_id)
             | Expr::Closure(block_id)
@@ -452,17 +461,14 @@ fn find_matching_block_end_in_expr(
                 }
             }
 
-            Expr::StringInterpolation(exprs) => exprs.iter().find_map(|expr| {
+            Expr::StringInterpolation(inner_expr) => {
-                find_matching_block_end_in_expr(
+                for inner_expr in inner_expr {
-                    line,
+                    find_in_expr_or_continue!(inner_expr);
-                    working_set,
+                }
-                    expr,
+                None
-                    global_span_offset,
+            }
-                    global_cursor_offset,
-                )
-            }),
 
-            Expr::List(list) => {
+            Expr::List(inner_expr) => {
                 if expr_last == global_cursor_offset {
                     // cursor is at list end
                     Some(expr_first)
@@ -470,15 +476,11 @@ fn find_matching_block_end_in_expr(
                     // cursor is at list start
                     Some(expr_last)
                 } else {
-                    list.iter().find_map(|item| {
+                    // cursor is inside list
-                        find_matching_block_end_in_expr(
+                    for inner_expr in inner_expr {
-                            line,
+                        find_in_expr_or_continue!(inner_expr);
-                            working_set,
+                    }
-                            item.expr(),
+                    None
-                            global_span_offset,
-                            global_cursor_offset,
-                        )
-                    })
                 }
             }
         };

crates/nu-cli/src/util.rs

@@ -4,7 +4,7 @@ use nu_parser::{escape_quote_string, lex, parse, unescape_unquote_string, Token,
 use nu_protocol::{
     debugger::WithoutDebug,
     engine::{EngineState, Stack, StateWorkingSet},
-    report_error, report_error_new, PipelineData, ShellError, Span, Value,
+    print_if_stream, report_error, report_error_new, PipelineData, ShellError, Span, Value,
 };
 #[cfg(windows)]
 use nu_utils::enable_vt_processing;
@@ -39,8 +39,9 @@ fn gather_env_vars(
     init_cwd: &Path,
 ) {
     fn report_capture_error(engine_state: &EngineState, env_str: &str, msg: &str) {
-        report_error_new(
+        let working_set = StateWorkingSet::new(engine_state);
-            engine_state,
+        report_error(
+            &working_set,
             &ShellError::GenericError {
                 error: format!("Environment variable was not captured: {env_str}"),
                 msg: "".into(),
@@ -70,8 +71,9 @@ fn gather_env_vars(
         }
         None => {
             // Could not capture current working directory
-            report_error_new(
+            let working_set = StateWorkingSet::new(engine_state);
-                engine_state,
+            report_error(
+                &working_set,
                 &ShellError::GenericError {
                     error: "Current directory is not a valid utf-8 path".into(),
                     msg: "".into(),
@@ -206,48 +208,9 @@ pub fn eval_source(
     fname: &str,
     input: PipelineData,
     allow_return: bool,
-) -> i32 {
+) -> bool {
     let start_time = std::time::Instant::now();
 
-    let exit_code = match evaluate_source(engine_state, stack, source, fname, input, allow_return) {
-        Ok(code) => code.unwrap_or(0),
-        Err(err) => {
-            report_error_new(engine_state, &err);
-            1
-        }
-    };
-
-    stack.add_env_var(
-        "LAST_EXIT_CODE".to_string(),
-        Value::int(exit_code.into(), Span::unknown()),
-    );
-
-    // reset vt processing, aka ansi because illbehaved externals can break it
-    #[cfg(windows)]
-    {
-        let _ = enable_vt_processing();
-    }
-
-    perf(
-        &format!("eval_source {}", &fname),
-        start_time,
-        file!(),
-        line!(),
-        column!(),
-        engine_state.get_config().use_ansi_coloring,
-    );
-
-    exit_code
-}
-
-fn evaluate_source(
-    engine_state: &mut EngineState,
-    stack: &mut Stack,
-    source: &[u8],
-    fname: &str,
-    input: PipelineData,
-    allow_return: bool,
-) -> Result<Option<i32>, ShellError> {
     let (block, delta) = {
         let mut working_set = StateWorkingSet::new(engine_state);
         let output = parse(
@@ -261,40 +224,104 @@ fn evaluate_source(
         }
 
         if let Some(err) = working_set.parse_errors.first() {
+            set_last_exit_code(stack, 1);
             report_error(&working_set, err);
-            return Ok(Some(1));
+            return false;
         }
 
         (output, working_set.render())
     };
 
-    engine_state.merge_delta(delta)?;
+    if let Err(err) = engine_state.merge_delta(delta) {
+        set_last_exit_code(stack, 1);
+        report_error_new(engine_state, &err);
+        return false;
+    }
 
-    let pipeline = if allow_return {
+    let b = if allow_return {
         eval_block_with_early_return::<WithoutDebug>(engine_state, stack, &block, input)
     } else {
         eval_block::<WithoutDebug>(engine_state, stack, &block, input)
-    }?;
-
-    let status = if let PipelineData::ByteStream(..) = pipeline {
-        pipeline.print(engine_state, stack, false, false)?
-    } else {
-        if let Some(hook) = engine_state.get_config().hooks.display_output.clone() {
-            let pipeline = eval_hook(
-                engine_state,
-                stack,
-                Some(pipeline),
-                vec![],
-                &hook,
-                "display_output",
-            )?;
-            pipeline.print(engine_state, stack, false, false)
-        } else {
-            pipeline.print(engine_state, stack, true, false)
-        }?
     };
 
-    Ok(status.map(|status| status.code()))
+    match b {
+        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,
+                    "display_output",
+                ) {
+                    Err(err) => {
+                        result = Err(err);
+                    }
+                    Ok(val) => {
+                        result = val.print(engine_state, stack, false, false);
+                    }
+                }
+            } else {
+                result = pipeline_data.print(engine_state, stack, true, false);
+            }
+
+            match result {
+                Err(err) => {
+                    let working_set = StateWorkingSet::new(engine_state);
+
+                    report_error(&working_set, &err);
+
+                    return false;
+                }
+                Ok(exit_code) => {
+                    set_last_exit_code(stack, exit_code);
+                }
+            }
+
+            // reset vt processing, aka ansi because illbehaved externals can break it
+            #[cfg(windows)]
+            {
+                let _ = enable_vt_processing();
+            }
+        }
+        Err(err) => {
+            set_last_exit_code(stack, 1);
+
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &err);
+
+            return false;
+        }
+    }
+    perf(
+        &format!("eval_source {}", &fname),
+        start_time,
+        file!(),
+        line!(),
+        column!(),
+        engine_state.get_config().use_ansi_coloring,
+    );
+
+    true
+}
+
+fn set_last_exit_code(stack: &mut Stack, exit_code: i64) {
+    stack.add_env_var(
+        "LAST_EXIT_CODE".to_string(),
+        Value::int(exit_code, Span::unknown()),
+    );
 }
 
 #[cfg(test)]

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

@@ -1 +0,0 @@
-mod nu_highlight;

crates/nu-cli/tests/commands/nu_highlight.rs

@@ -1,7 +0,0 @@
-use nu_test_support::nu;
-
-#[test]
-fn nu_highlight_not_expr() {
-    let actual = nu!("'not false' | nu-highlight | ansi strip");
-    assert_eq!(actual.out, "not false");
-}

crates/nu-cli/tests/completions.rs

@@ -1,15 +1,11 @@
 pub mod support;
 
 use nu_cli::NuCompleter;
-use nu_engine::eval_block;
 use nu_parser::parse;
-use nu_protocol::{debugger::WithoutDebug, engine::StateWorkingSet, PipelineData};
+use nu_protocol::engine::StateWorkingSet;
 use reedline::{Completer, Suggestion};
 use rstest::{fixture, rstest};
-use std::{
+use std::path::PathBuf;
-    path::{PathBuf, MAIN_SEPARATOR},
-    sync::Arc,
-};
 use support::{
     completions_helpers::{new_partial_engine, new_quote_engine},
     file, folder, match_suggestions, new_engine,
@@ -25,7 +21,7 @@ fn completer() -> NuCompleter {
     assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
 
     // Instantiate a new completer
-    NuCompleter::new(Arc::new(engine), Arc::new(stack))
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
 }
 
 #[fixture]
@@ -39,7 +35,7 @@ fn completer_strings() -> NuCompleter {
     assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
 
     // Instantiate a new completer
-    NuCompleter::new(Arc::new(engine), Arc::new(stack))
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
 }
 
 #[fixture]
@@ -59,7 +55,7 @@ fn extern_completer() -> NuCompleter {
     assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
 
     // Instantiate a new completer
-    NuCompleter::new(Arc::new(engine), Arc::new(stack))
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
 }
 
 #[fixture]
@@ -82,14 +78,14 @@ fn custom_completer() -> NuCompleter {
     assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
 
     // Instantiate a new completer
-    NuCompleter::new(Arc::new(engine), Arc::new(stack))
+    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(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let target_dir = "$ ";
     let suggestions = completer.complete(target_dir, target_dir.len());
@@ -141,7 +137,7 @@ fn dotnu_completions() {
     let (_, _, engine, stack) = new_engine();
 
     // Instantiate a new completer
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Test source completion
     let completion_str = "source-env ".to_string();
@@ -181,7 +177,7 @@ fn dotnu_completions() {
 #[ignore]
 fn external_completer_trailing_space() {
     // https://github.com/nushell/nushell/issues/6378
-    let block = "{|spans| $spans}";
+    let block = "let external_completer = {|spans| $spans}";
     let input = "gh alias ".to_string();
 
     let suggestions = run_external_completion(block, &input);
@@ -220,10 +216,10 @@ fn file_completions() {
     let (dir, dir_str, engine, stack) = new_engine();
 
     // Instantiate a new completer
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Test completions for the current folder
-    let target_dir = format!("cp {dir_str}{MAIN_SEPARATOR}");
+    let target_dir = format!("cp {dir_str}");
     let suggestions = completer.complete(&target_dir, target_dir.len());
 
     // Create the expected values
@@ -268,7 +264,7 @@ fn partial_completions() {
     let (dir, _, engine, stack) = new_partial_engine();
 
     // Instantiate a new completer
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Test completions for a folder's name
     let target_dir = format!("cd {}", file(dir.join("pa")));
@@ -292,8 +288,6 @@ fn partial_completions() {
 
     // Create the expected values
     let expected_paths: Vec<String> = vec![
-        file(dir.join("partial_a").join("have_ext.exe")),
-        file(dir.join("partial_a").join("have_ext.txt")),
         file(dir.join("partial_a").join("hello")),
         file(dir.join("partial_a").join("hola")),
         file(dir.join("partial_b").join("hello_b")),
@@ -312,8 +306,6 @@ fn partial_completions() {
     // Create the expected values
     let expected_paths: Vec<String> = vec![
         file(dir.join("partial_a").join("anotherfile")),
-        file(dir.join("partial_a").join("have_ext.exe")),
-        file(dir.join("partial_a").join("have_ext.txt")),
         file(dir.join("partial_a").join("hello")),
         file(dir.join("partial_a").join("hola")),
         file(dir.join("partial_b").join("hello_b")),
@@ -341,54 +333,7 @@ fn partial_completions() {
     let suggestions = completer.complete(&target_dir, target_dir.len());
 
     // Create the expected values
-    let expected_paths: Vec<String> = vec![
+    let expected_paths: Vec<String> = vec![file(dir.join("final_partial").join("somefile"))];
-        file(
-            dir.join("partial_a")
-                .join("..")
-                .join("final_partial")
-                .join("somefile"),
-        ),
-        file(
-            dir.join("partial_b")
-                .join("..")
-                .join("final_partial")
-                .join("somefile"),
-        ),
-        file(
-            dir.join("partial_c")
-                .join("..")
-                .join("final_partial")
-                .join("somefile"),
-        ),
-    ];
-
-    // Match the results
-    match_suggestions(expected_paths, suggestions);
-
-    // Test completion for all files under directories whose names begin with "pa"
-    let file_str = file(dir.join("partial_a").join("have"));
-    let target_file = format!("rm {file_str}");
-    let suggestions = completer.complete(&target_file, target_file.len());
-
-    // Create the expected values
-    let expected_paths: Vec<String> = vec![
-        file(dir.join("partial_a").join("have_ext.exe")),
-        file(dir.join("partial_a").join("have_ext.txt")),
-    ];
-
-    // Match the results
-    match_suggestions(expected_paths, suggestions);
-
-    // Test completion for all files under directories whose names begin with "pa"
-    let file_str = file(dir.join("partial_a").join("have_ext."));
-    let file_dir = format!("rm {file_str}");
-    let suggestions = completer.complete(&file_dir, file_dir.len());
-
-    // Create the expected values
-    let expected_paths: Vec<String> = vec![
-        file(dir.join("partial_a").join("have_ext.exe")),
-        file(dir.join("partial_a").join("have_ext.txt")),
-    ];
 
     // Match the results
     match_suggestions(expected_paths, suggestions);
@@ -398,7 +343,7 @@ fn partial_completions() {
 fn command_ls_with_filecompletion() {
     let (_, _, engine, stack) = new_engine();
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let target_dir = "ls ";
     let suggestions = completer.complete(target_dir, target_dir.len());
@@ -426,20 +371,13 @@ fn command_ls_with_filecompletion() {
         ".hidden_folder/".to_string(),
     ];
 
-    match_suggestions(expected_paths, suggestions);
-
-    let target_dir = "ls custom_completion.";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    let expected_paths: Vec<String> = vec!["custom_completion.nu".to_string()];
-
     match_suggestions(expected_paths, suggestions)
 }
 #[test]
 fn command_open_with_filecompletion() {
     let (_, _, engine, stack) = new_engine();
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let target_dir = "open ";
     let suggestions = completer.complete(target_dir, target_dir.len());
@@ -467,13 +405,6 @@ fn command_open_with_filecompletion() {
         ".hidden_folder/".to_string(),
     ];
 
-    match_suggestions(expected_paths, suggestions);
-
-    let target_dir = "open custom_completion.";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    let expected_paths: Vec<String> = vec!["custom_completion.nu".to_string()];
-
     match_suggestions(expected_paths, suggestions)
 }
 
@@ -481,7 +412,7 @@ fn command_open_with_filecompletion() {
 fn command_rm_with_globcompletion() {
     let (_, _, engine, stack) = new_engine();
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let target_dir = "rm ";
     let suggestions = completer.complete(target_dir, target_dir.len());
@@ -516,7 +447,7 @@ fn command_rm_with_globcompletion() {
 fn command_cp_with_globcompletion() {
     let (_, _, engine, stack) = new_engine();
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let target_dir = "cp ";
     let suggestions = completer.complete(target_dir, target_dir.len());
@@ -551,7 +482,7 @@ fn command_cp_with_globcompletion() {
 fn command_save_with_filecompletion() {
     let (_, _, engine, stack) = new_engine();
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let target_dir = "save ";
     let suggestions = completer.complete(target_dir, target_dir.len());
@@ -586,7 +517,7 @@ fn command_save_with_filecompletion() {
 fn command_touch_with_filecompletion() {
     let (_, _, engine, stack) = new_engine();
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let target_dir = "touch ";
     let suggestions = completer.complete(target_dir, target_dir.len());
@@ -621,7 +552,7 @@ fn command_touch_with_filecompletion() {
 fn command_watch_with_filecompletion() {
     let (_, _, engine, stack) = new_engine();
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let target_dir = "watch ";
     let suggestions = completer.complete(target_dir, target_dir.len());
@@ -656,7 +587,7 @@ fn command_watch_with_filecompletion() {
 fn file_completion_quoted() {
     let (_, _, engine, stack) = new_quote_engine();
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let target_dir = "open ";
     let suggestions = completer.complete(target_dir, target_dir.len());
@@ -694,7 +625,7 @@ fn flag_completions() {
     let (_, _, engine, stack) = new_engine();
 
     // Instantiate a new completer
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
     // Test completions for the 'ls' flags
     let suggestions = completer.complete("ls -", 4);
 
@@ -729,10 +660,10 @@ fn folder_with_directorycompletions() {
     let (dir, dir_str, engine, stack) = new_engine();
 
     // Instantiate a new completer
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Test completions for the current folder
-    let target_dir = format!("cd {dir_str}{MAIN_SEPARATOR}");
+    let target_dir = format!("cd {dir_str}");
     let suggestions = completer.complete(&target_dir, target_dir.len());
 
     // Create the expected values
@@ -758,7 +689,7 @@ fn variables_completions() {
     assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
 
     // Instantiate a new completer
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Test completions for $nu
     let suggestions = completer.complete("$nu.", 4);
@@ -864,7 +795,7 @@ fn alias_of_command_and_flags() {
     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(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let suggestions = completer.complete("ll t", 4);
     #[cfg(windows)]
@@ -883,7 +814,7 @@ fn alias_of_basic_command() {
     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(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let suggestions = completer.complete("ll t", 4);
     #[cfg(windows)]
@@ -905,7 +836,7 @@ fn alias_of_another_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(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let suggestions = completer.complete("lf t", 4);
     #[cfg(windows)]
@@ -916,14 +847,12 @@ fn alias_of_another_alias() {
     match_suggestions(expected_paths, suggestions)
 }
 
-fn run_external_completion(completer: &str, input: &str) -> Vec<Suggestion> {
+fn run_external_completion(block: &str, input: &str) -> Vec<Suggestion> {
-    let completer = format!("$env.config.completions.external.completer = {completer}");
-
     // Create a new engine
     let (dir, _, mut engine_state, mut stack) = new_engine();
-    let (block, delta) = {
+    let (_, delta) = {
         let mut working_set = StateWorkingSet::new(&engine_state);
-        let block = parse(&mut working_set, None, completer.as_bytes(), false);
+        let block = parse(&mut working_set, None, block.as_bytes(), false);
         assert!(working_set.parse_errors.is_empty());
 
         (block, working_set.render())
@@ -931,15 +860,18 @@ fn run_external_completion(completer: &str, input: &str) -> Vec<Suggestion> {
 
     assert!(engine_state.merge_delta(delta).is_ok());
 
-    assert!(
-        eval_block::<WithoutDebug>(&engine_state, &mut stack, &block, PipelineData::Empty).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);
+
     // Instantiate a new completer
-    let mut completer = NuCompleter::new(Arc::new(engine_state), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine_state), stack);
 
     completer.complete(input, input.len())
 }
@@ -948,7 +880,7 @@ fn run_external_completion(completer: &str, input: &str) -> Vec<Suggestion> {
 fn unknown_command_completion() {
     let (_, _, engine, stack) = new_engine();
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let target_dir = "thiscommanddoesnotexist ";
     let suggestions = completer.complete(target_dir, target_dir.len());
@@ -1011,7 +943,7 @@ fn flagcompletion_triggers_after_cursor_piped(mut completer: NuCompleter) {
 fn filecompletions_triggers_after_cursor() {
     let (_, _, engine, stack) = new_engine();
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     let suggestions = completer.complete("cp   test_c", 3);
 
@@ -1120,7 +1052,7 @@ fn alias_offset_bug_7648() {
     let alias = r#"alias ea = ^$env.EDITOR /tmp/test.s"#;
     assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
 
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Issue #7648
     // Nushell crashes when an alias name is shorter than the alias command
@@ -1139,7 +1071,7 @@ fn alias_offset_bug_7754() {
     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(Arc::new(engine), Arc::new(stack));
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Issue #7754
     // Nushell crashes when an alias name is shorter than the alias command

crates/nu-cli/tests/main.rs

@@ -1,2 +0,0 @@
-mod commands;
-mod completions;

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

@@ -3,11 +3,14 @@ use nu_parser::parse;
 use nu_protocol::{
     debugger::WithoutDebug,
     engine::{EngineState, Stack, StateWorkingSet},
-    PipelineData, ShellError, Span, Value,
+    eval_const::create_nu_constant,
+    PipelineData, ShellError, Span, Value, NU_VARIABLE_ID,
 };
 use nu_test_support::fs;
 use reedline::Suggestion;
-use std::path::{PathBuf, MAIN_SEPARATOR};
+use std::path::PathBuf;
+
+const SEP: char = std::path::MAIN_SEPARATOR;
 
 fn create_default_context() -> EngineState {
     nu_command::add_shell_command_context(nu_cmd_lang::create_default_context())
@@ -17,17 +20,20 @@ fn create_default_context() -> EngineState {
 pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
     // Target folder inside assets
     let dir = fs::fixtures().join("completions");
-    let dir_str = dir
+    let mut dir_str = dir
         .clone()
         .into_os_string()
         .into_string()
         .unwrap_or_default();
+    dir_str.push(SEP);
 
     // Create a new engine with default context
     let mut engine_state = create_default_context();
 
     // Add $nu
-    engine_state.generate_nu_constant();
+    let nu_const =
+        create_nu_constant(&engine_state, Span::test_data()).expect("Failed creating $nu");
+    engine_state.set_variable_const_val(NU_VARIABLE_ID, nu_const);
 
     // New stack
     let mut stack = Stack::new();
@@ -71,11 +77,12 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
 pub fn new_quote_engine() -> (PathBuf, String, EngineState, Stack) {
     // Target folder inside assets
     let dir = fs::fixtures().join("quoted_completions");
-    let dir_str = dir
+    let mut dir_str = dir
         .clone()
         .into_os_string()
         .into_string()
         .unwrap_or_default();
+    dir_str.push(SEP);
 
     // Create a new engine with default context
     let mut engine_state = create_default_context();
@@ -106,11 +113,12 @@ pub fn new_quote_engine() -> (PathBuf, String, EngineState, Stack) {
 pub fn new_partial_engine() -> (PathBuf, String, EngineState, Stack) {
     // Target folder inside assets
     let dir = fs::fixtures().join("partial_completions");
-    let dir_str = dir
+    let mut dir_str = dir
         .clone()
         .into_os_string()
         .into_string()
         .unwrap_or_default();
+    dir_str.push(SEP);
 
     // Create a new engine with default context
     let mut engine_state = create_default_context();
@@ -157,7 +165,7 @@ pub fn match_suggestions(expected: Vec<String>, suggestions: Vec<Suggestion>) {
 // append the separator to the converted path
 pub fn folder(path: PathBuf) -> String {
     let mut converted_path = file(path);
-    converted_path.push(MAIN_SEPARATOR);
+    converted_path.push(SEP);
 
     converted_path
 }

crates/nu-cmd-base/Cargo.toml

@@ -5,17 +5,17 @@ edition = "2021"
 license = "MIT"
 name = "nu-cmd-base"
 repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cmd-base"
-version = "0.94.2"
+version = "0.92.2"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-engine = { path = "../nu-engine", version = "0.94.2" }
+nu-engine = { path = "../nu-engine", version = "0.92.2" }
-nu-parser = { path = "../nu-parser", version = "0.94.2" }
+nu-parser = { path = "../nu-parser", version = "0.92.2" }
-nu-path = { path = "../nu-path", version = "0.94.2" }
+nu-path = { path = "../nu-path", version = "0.92.2" }
-nu-protocol = { path = "../nu-protocol", version = "0.94.2" }
+nu-protocol = { path = "../nu-protocol", version = "0.92.2" }
 
 indexmap = { workspace = true }
 miette = { workspace = true }
 
-[dev-dependencies]
+[dev-dependencies]

crates/nu-cmd-base/src/hook.rs

@@ -5,8 +5,8 @@ use nu_parser::parse;
 use nu_protocol::{
     cli_error::{report_error, report_error_new},
     debugger::WithoutDebug,
-    engine::{Closure, EngineState, Stack, StateWorkingSet},
+    engine::{EngineState, Stack, StateWorkingSet},
-    PipelineData, PositionalArg, ShellError, Span, Type, Value, VarId,
+    BlockId, PipelineData, PositionalArg, ShellError, Span, Type, Value, VarId,
 };
 use std::sync::Arc;
 
@@ -153,11 +153,11 @@ pub fn eval_hook(
             // If it returns true (the default if a condition block is not specified), the hook should be run.
             let do_run_hook = if let Some(condition) = val.get("condition") {
                 let other_span = condition.span();
-                if let Ok(closure) = condition.as_closure() {
+                if let Ok(block_id) = condition.coerce_block() {
-                    match run_hook(
+                    match run_hook_block(
                         engine_state,
                         stack,
-                        closure,
+                        block_id,
                         None,
                         arguments.clone(),
                         other_span,
@@ -259,8 +259,25 @@ pub fn eval_hook(
                             stack.remove_var(*var_id);
                         }
                     }
+                    Value::Block { val: block_id, .. } => {
+                        run_hook_block(
+                            engine_state,
+                            stack,
+                            *block_id,
+                            input,
+                            arguments,
+                            source_span,
+                        )?;
+                    }
                     Value::Closure { val, .. } => {
-                        run_hook(engine_state, stack, val, input, arguments, source_span)?;
+                        run_hook_block(
+                            engine_state,
+                            stack,
+                            val.block_id,
+                            input,
+                            arguments,
+                            source_span,
+                        )?;
                     }
                     other => {
                         return Err(ShellError::UnsupportedConfigValue {
@@ -272,8 +289,11 @@ pub fn eval_hook(
                 }
             }
         }
+        Value::Block { val: block_id, .. } => {
+            output = run_hook_block(engine_state, stack, *block_id, input, arguments, span)?;
+        }
         Value::Closure { val, .. } => {
-            output = run_hook(engine_state, stack, val, input, arguments, span)?;
+            output = run_hook_block(engine_state, stack, val.block_id, input, arguments, span)?;
         }
         other => {
             return Err(ShellError::UnsupportedConfigValue {
@@ -290,20 +310,20 @@ pub fn eval_hook(
     Ok(output)
 }
 
-fn run_hook(
+fn run_hook_block(
     engine_state: &EngineState,
     stack: &mut Stack,
-    closure: &Closure,
+    block_id: BlockId,
     optional_input: Option<PipelineData>,
     arguments: Vec<(String, Value)>,
     span: Span,
 ) -> Result<PipelineData, ShellError> {
-    let block = engine_state.get_block(closure.block_id);
+    let block = engine_state.get_block(block_id);
 
     let input = optional_input.unwrap_or_else(PipelineData::empty);
 
     let mut callee_stack = stack
-        .captures_to_stack_preserve_out_dest(closure.captures.clone())
+        .gather_captures(engine_state, &block.captures)
         .reset_pipes();
 
     for (idx, PositionalArg { var_id, .. }) in

crates/nu-cmd-base/src/util.rs

@@ -1,8 +1,9 @@
 use nu_protocol::{
-    engine::{EngineState, Stack},
+    ast::RangeInclusion,
-    Range, ShellError, Span, Value,
+    engine::{EngineState, Stack, StateWorkingSet},
+    report_error, Range, ShellError, Span, Value,
 };
-use std::{ops::Bound, path::PathBuf};
+use std::path::PathBuf;
 
 pub fn get_init_cwd() -> PathBuf {
     std::env::current_dir().unwrap_or_else(|_| {
@@ -13,29 +14,45 @@ pub fn get_init_cwd() -> PathBuf {
 }
 
 pub fn get_guaranteed_cwd(engine_state: &EngineState, stack: &Stack) -> PathBuf {
-    engine_state
+    nu_engine::env::current_dir(engine_state, stack).unwrap_or_else(|e| {
-        .cwd(Some(stack))
+        let working_set = StateWorkingSet::new(engine_state);
-        .unwrap_or(crate::util::get_init_cwd())
+        report_error(&working_set, &e);
+        crate::util::get_init_cwd()
+    })
 }
 
 type MakeRangeError = fn(&str, Span) -> ShellError;
 
 pub fn process_range(range: &Range) -> Result<(isize, isize), MakeRangeError> {
-    match range {
+    let start = match &range.from {
-        Range::IntRange(range) => {
+        Value::Int { val, .. } => isize::try_from(*val).unwrap_or_default(),
-            let start = range.start().try_into().unwrap_or(0);
+        Value::Nothing { .. } => 0,
-            let end = match range.end() {
+        _ => {
-                Bound::Included(v) => (v + 1) as isize,
+            return Err(|msg, span| ShellError::TypeMismatch {
-                Bound::Excluded(v) => v as isize,
+                err_message: msg.to_string(),
-                Bound::Unbounded => isize::MAX,
+                span,
-            };
+            })
-            Ok((start, end))
         }
-        Range::FloatRange(_) => Err(|msg, span| ShellError::TypeMismatch {
+    };
-            err_message: msg.to_string(),
+
-            span,
+    let end = match &range.to {
-        }),
+        Value::Int { val, .. } => {
-    }
+            if matches!(range.inclusion, RangeInclusion::Inclusive) {
+                isize::try_from(*val).unwrap_or(isize::max_value())
+            } else {
+                isize::try_from(*val).unwrap_or(isize::max_value()) - 1
+            }
+        }
+        Value::Nothing { .. } => isize::max_value(),
+        _ => {
+            return Err(|msg, span| ShellError::TypeMismatch {
+                err_message: msg.to_string(),
+                span,
+            })
+        }
+    };
+
+    Ok((start, end))
 }
 
 const HELP_MSG: &str = "Nushell's config file can be found with the command: $nu.config-path. \

crates/nu-cmd-dataframe/Cargo.toml

@@ -0,0 +1,75 @@
+[package]
+authors = ["The Nushell Project Developers"]
+description = "Nushell's dataframe commands based on polars."
+edition = "2021"
+license = "MIT"
+name = "nu-cmd-dataframe"
+repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cmd-dataframe"
+version = "0.92.2"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+bench = false
+
+[dependencies]
+nu-engine = { path = "../nu-engine", version = "0.92.2" }
+nu-parser = { path = "../nu-parser", version = "0.92.2" }
+nu-protocol = { path = "../nu-protocol", version = "0.92.2" }
+
+# Potential dependencies for extras
+chrono = { workspace = true, features = ["std", "unstable-locales"], default-features = false }
+chrono-tz = { workspace = true }
+fancy-regex = { workspace = true }
+indexmap = { workspace = true }
+num = { version = "0.4", optional = true }
+serde = { workspace = true, features = ["derive"] }
+# keep sqlparser at 0.39.0 until we can update polars
+sqlparser = { version = "0.39.0", optional = true }
+polars-io = { version = "0.37", features = ["avro"], optional = true }
+polars-arrow = { version = "0.37", optional = true }
+polars-ops = { version = "0.37", optional = true }
+polars-plan = { version = "0.37", features = ["regex"], optional = true }
+polars-utils = { version = "0.37", optional = true }
+
+[dependencies.polars]
+features = [
+	"arg_where",
+	"checked_arithmetic",
+	"concat_str",
+	"cross_join",
+	"csv",
+	"cum_agg",
+	"dtype-categorical",
+	"dtype-datetime",
+	"dtype-struct",
+	"dtype-i8",
+	"dtype-i16",
+	"dtype-u8",
+	"dtype-u16",
+	"dynamic_group_by",
+	"ipc",
+	"is_in",
+	"json",
+	"lazy",
+	"object",
+	"parquet",
+	"random",
+	"rolling_window",
+	"rows",
+	"serde",
+	"serde-lazy",
+	"strings",
+	"temporal",
+	"to_dummies",
+]
+default-features = false
+optional = true
+version = "0.37"
+
+[features]
+dataframe = ["num", "polars", "polars-io", "polars-arrow", "polars-ops", "polars-plan", "polars-utils", "sqlparser"]
+default = []
+
+[dev-dependencies]
+nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.92.2" }

crates/nu-cmd-dataframe/src/dataframe/eager/append.rs

@@ -1,24 +1,22 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{Axis, Column, NuDataFrame};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
-};
-
-use crate::{
-    values::{Axis, Column, CustomValueSupport, NuDataFrame},
-    PolarsPlugin,
-};
 
 #[derive(Clone)]
 pub struct AppendDF;
 
-impl PluginCommand for AppendDF {
+impl Command for AppendDF {
-    type Plugin = PolarsPlugin;
+    fn name(&self) -> &str {
+        "dfr append"
+    }
+
+    fn usage(&self) -> &str {
+        "Appends a new dataframe."
+    }
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
-            .required("other", SyntaxShape::Any, "other dataframe to append")
+            .required("other", SyntaxShape::Any, "dataframe to be appended")
-            .switch("col", "append as new columns instead of rows", Some('c'))
+            .switch("col", "appends in col orientation", Some('c'))
             .input_output_type(
                 Type::Custom("dataframe".into()),
                 Type::Custom("dataframe".into()),
@@ -26,30 +24,12 @@ impl PluginCommand for AppendDF {
             .category(Category::Custom("dataframe".into()))
     }
 
-    fn run(
-        &self,
-        plugin: &Self::Plugin,
-        engine: &EngineInterface,
-        call: &EvaluatedCall,
-        input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
-    }
-
-    fn name(&self) -> &str {
-        "polars append"
-    }
-
-    fn usage(&self) -> &str {
-        "Appends a new dataframe."
-    }
-
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
                 description: "Appends a dataframe as new columns",
-                example: r#"let a = ([[a b]; [1 2] [3 4]] | polars into-df);
+                example: r#"let a = ([[a b]; [1 2] [3 4]] | dfr into-df);
-    $a | polars append $a"#,
+    $a | dfr append $a"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -78,7 +58,8 @@ impl PluginCommand for AppendDF {
             },
             Example {
                 description: "Appends a dataframe merging at the end of columns",
-                example: r#"let a = ([[a b]; [1 2] [3 4]] | polars into-df); $a | polars append $a --col"#,
+                example: r#"let a = ([[a b]; [1 2] [3 4]] | dfr into-df);
+    $a | dfr append $a --col"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -109,36 +90,45 @@ impl PluginCommand for AppendDF {
             },
         ]
     }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        command(engine_state, stack, call, input)
+    }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let other: Value = call.req(0)?;
+    let other: Value = call.req(engine_state, stack, 0)?;
 
-    let axis = if call.has_flag("col")? {
+    let axis = if call.has_flag(engine_state, stack, "col")? {
         Axis::Column
     } else {
         Axis::Row
     };
+    let df_other = NuDataFrame::try_from_value(other)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
-    let df_other = NuDataFrame::try_from_value_coerce(plugin, &other, call.head)?;
+    df.append_df(&df_other, axis, call.head)
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+        .map(|df| PipelineData::Value(NuDataFrame::into_value(df, call.head), None))
-    let df = df.append_df(&df_other, axis, call.head)?;
-
-    df.to_pipeline_data(plugin, engine, call.head)
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&AppendDF)
+        test_dataframe(vec![Box::new(AppendDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/cast.rs

@@ -1,25 +1,14 @@
-use crate::{
+use crate::dataframe::values::{str_to_dtype, NuDataFrame, NuExpression, NuLazyFrame};
-    dataframe::values::{str_to_dtype, NuExpression, NuLazyFrame},
+use nu_engine::command_prelude::*;
-    values::{cant_convert_err, CustomValueSupport, PolarsPluginObject, PolarsPluginType},
-    PolarsPlugin,
-};
 
-use super::super::values::NuDataFrame;
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    record, Category, Example, LabeledError, PipelineData, ShellError, Signature, Span,
-    SyntaxShape, Type, Value,
-};
 use polars::prelude::*;
 
 #[derive(Clone)]
 pub struct CastDF;
 
-impl PluginCommand for CastDF {
+impl Command for CastDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars cast"
+        "dfr cast"
     }
 
     fn usage(&self) -> &str {
@@ -55,7 +44,7 @@ impl PluginCommand for CastDF {
         vec![
             Example {
                 description: "Cast a column in a dataframe to a different dtype",
-                example: "[[a b]; [1 2] [3 4]] | polars into-df | polars cast u8 a | polars schema",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr cast u8 a | dfr schema",
                 result: Some(Value::record(
                     record! {
                         "a" => Value::string("u8", Span::test_data()),
@@ -66,8 +55,7 @@ impl PluginCommand for CastDF {
             },
             Example {
                 description: "Cast a column in a lazy dataframe to a different dtype",
-                example:
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr into-lazy | dfr cast u8 a | dfr schema",
-                    "[[a b]; [1 2] [3 4]] | polars into-df | polars into-lazy | polars cast u8 a | polars schema",
                 result: Some(Value::record(
                     record! {
                         "a" => Value::string("u8", Span::test_data()),
@@ -78,85 +66,90 @@ impl PluginCommand for CastDF {
             },
             Example {
                 description: "Cast a column in a expression to a different dtype",
-                example: r#"[[a b]; [1 2] [1 4]] | polars into-df | polars group-by a | polars agg [ (polars col b | polars cast u8 | polars min | polars as "b_min") ] | polars schema"#,
+                example: r#"[[a b]; [1 2] [1 4]] | dfr into-df | dfr group-by a | dfr agg [ (dfr col b | dfr cast u8 | dfr min | dfr as "b_min") ] | dfr schema"#,
-                result: None,
+                result: None
-            },
+            }
         ]
     }
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let value = input.into_value(call.head)?;
+        let value = input.into_value(call.head);
-        match PolarsPluginObject::try_from_value(plugin, &value)? {
+        if NuLazyFrame::can_downcast(&value) {
-            PolarsPluginObject::NuLazyFrame(lazy) => {
+            let (dtype, column_nm) = df_args(engine_state, stack, call)?;
-                let (dtype, column_nm) = df_args(call)?;
+            let df = NuLazyFrame::try_from_value(value)?;
-                command_lazy(plugin, engine, call, column_nm, dtype, lazy)
+            command_lazy(call, column_nm, dtype, df)
-            }
+        } else if NuDataFrame::can_downcast(&value) {
-            PolarsPluginObject::NuDataFrame(df) => {
+            let (dtype, column_nm) = df_args(engine_state, stack, call)?;
-                let (dtype, column_nm) = df_args(call)?;
+            let df = NuDataFrame::try_from_value(value)?;
-                command_eager(plugin, engine, call, column_nm, dtype, df)
+            command_eager(call, column_nm, dtype, df)
-            }
+        } else {
-            PolarsPluginObject::NuExpression(expr) => {
+            let dtype: String = call.req(engine_state, stack, 0)?;
-                let dtype: String = call.req(0)?;
+            let dtype = str_to_dtype(&dtype, call.head)?;
-                let dtype = str_to_dtype(&dtype, call.head)?;
+
-                let expr: NuExpression = expr.into_polars().cast(dtype).into();
+            let expr = NuExpression::try_from_value(value)?;
-                expr.to_pipeline_data(plugin, engine, call.head)
+            let expr: NuExpression = expr.into_polars().cast(dtype).into();
-            }
+
-            _ => Err(cant_convert_err(
+            Ok(PipelineData::Value(
-                &value,
+                NuExpression::into_value(expr, call.head),
-                &[
+                None,
-                    PolarsPluginType::NuDataFrame,
+            ))
-                    PolarsPluginType::NuLazyFrame,
-                    PolarsPluginType::NuExpression,
-                ],
-            )),
         }
-        .map_err(LabeledError::from)
     }
 }
 
-fn df_args(call: &EvaluatedCall) -> Result<(DataType, String), ShellError> {
+fn df_args(
-    let dtype = dtype_arg(call)?;
+    engine_state: &EngineState,
-    let column_nm: String = call.opt(1)?.ok_or(ShellError::MissingParameter {
+    stack: &mut Stack,
-        param_name: "column_name".into(),
+    call: &Call,
-        span: call.head,
+) -> Result<(DataType, String), ShellError> {
-    })?;
+    let dtype = dtype_arg(engine_state, stack, call)?;
+    let column_nm: String =
+        call.opt(engine_state, stack, 1)?
+            .ok_or(ShellError::MissingParameter {
+                param_name: "column_name".into(),
+                span: call.head,
+            })?;
     Ok((dtype, column_nm))
 }
 
-fn dtype_arg(call: &EvaluatedCall) -> Result<DataType, ShellError> {
+fn dtype_arg(
-    let dtype: String = call.req(0)?;
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+) -> Result<DataType, ShellError> {
+    let dtype: String = call.req(engine_state, stack, 0)?;
     str_to_dtype(&dtype, call.head)
 }
 
 fn command_lazy(
-    plugin: &PolarsPlugin,
+    call: &Call,
-    engine: &EngineInterface,
-    call: &EvaluatedCall,
     column_nm: String,
     dtype: DataType,
     lazy: NuLazyFrame,
 ) -> Result<PipelineData, ShellError> {
     let column = col(&column_nm).cast(dtype);
-    let lazy = lazy.to_polars().with_columns(&[column]);
+    let lazy = lazy.into_polars().with_columns(&[column]);
     let lazy = NuLazyFrame::new(false, lazy);
-    lazy.to_pipeline_data(plugin, engine, call.head)
+
+    Ok(PipelineData::Value(
+        NuLazyFrame::into_value(lazy, call.head)?,
+        None,
+    ))
 }
 
 fn command_eager(
-    plugin: &PolarsPlugin,
+    call: &Call,
-    engine: &EngineInterface,
-    call: &EvaluatedCall,
     column_nm: String,
     dtype: DataType,
     nu_df: NuDataFrame,
 ) -> Result<PipelineData, ShellError> {
-    let mut df = (*nu_df.df).clone();
+    let mut df = nu_df.df;
     let column = df
         .column(&column_nm)
         .map_err(|e| ShellError::GenericError {
@@ -186,17 +179,17 @@ fn command_eager(
         })?;
 
     let df = NuDataFrame::new(false, df);
-    df.to_pipeline_data(plugin, engine, call.head)
+    Ok(PipelineData::Value(df.into_value(call.head), None))
 }
 
 #[cfg(test)]
 mod test {
 
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&CastDF)
+        test_dataframe(vec![Box::new(CastDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/columns.rs

@@ -1,19 +1,12 @@
-use crate::PolarsPlugin;
+use crate::dataframe::values::NuDataFrame;
-
+use nu_engine::command_prelude::*;
-use super::super::values::NuDataFrame;
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, Type, Value,
-};
 
 #[derive(Clone)]
 pub struct ColumnsDF;
 
-impl PluginCommand for ColumnsDF {
+impl Command for ColumnsDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars columns"
+        "dfr columns"
     }
 
     fn usage(&self) -> &str {
@@ -29,7 +22,7 @@ impl PluginCommand for ColumnsDF {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Dataframe columns",
-            example: "[[a b]; [1 2] [3 4]] | polars into-df | polars columns",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr columns",
             result: Some(Value::list(
                 vec![Value::test_string("a"), Value::test_string("b")],
                 Span::test_data(),
@@ -39,21 +32,22 @@ impl PluginCommand for ColumnsDF {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        _engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, call, input).map_err(|e| e.into())
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    _engine_state: &EngineState,
-    call: &EvaluatedCall,
+    _stack: &mut Stack,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
     let names: Vec<Value> = df
         .as_ref()
@@ -69,11 +63,11 @@ fn command(
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ColumnsDF)
+        test_dataframe(vec![Box::new(ColumnsDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/drop.rs

@@ -1,23 +1,12 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{utils::convert_columns, Column, NuDataFrame};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
-};
-
-use crate::values::CustomValueSupport;
-use crate::PolarsPlugin;
-
-use super::super::values::utils::convert_columns;
-use super::super::values::{Column, NuDataFrame};
 
 #[derive(Clone)]
 pub struct DropDF;
 
-impl PluginCommand for DropDF {
+impl Command for DropDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars drop"
+        "dfr drop"
     }
 
     fn usage(&self) -> &str {
@@ -37,7 +26,7 @@ impl PluginCommand for DropDF {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "drop column a",
-            example: "[[a b]; [1 2] [3 4]] | polars into-df | polars drop a",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr drop a",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![Column::new(
@@ -54,25 +43,25 @@ impl PluginCommand for DropDF {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let columns: Vec<Value> = call.rest(0)?;
+    let columns: Vec<Value> = call.rest(engine_state, stack, 0)?;
     let (col_string, col_span) = convert_columns(columns, call.head)?;
 
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
     let new_df = col_string
         .first()
@@ -97,30 +86,30 @@ fn command(
 
     // If there are more columns in the drop selection list, these
     // are added from the resulting dataframe
-    let polars_df = col_string.iter().skip(1).try_fold(new_df, |new_df, col| {
+    col_string
-        new_df
+        .iter()
-            .drop(&col.item)
+        .skip(1)
-            .map_err(|e| ShellError::GenericError {
+        .try_fold(new_df, |new_df, col| {
-                error: "Error dropping column".into(),
+            new_df
-                msg: e.to_string(),
+                .drop(&col.item)
-                span: Some(col.span),
+                .map_err(|e| ShellError::GenericError {
-                help: None,
+                    error: "Error dropping column".into(),
-                inner: vec![],
+                    msg: e.to_string(),
-            })
+                    span: Some(col.span),
-    })?;
+                    help: None,
-
+                    inner: vec![],
-    let final_df = NuDataFrame::new(df.from_lazy, polars_df);
+                })
-
+        })
-    final_df.to_pipeline_data(plugin, engine, call.head)
+        .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&DropDF)
+        test_dataframe(vec![Box::new(DropDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/drop_duplicates.rs

@@ -1,24 +1,14 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{utils::convert_columns_string, Column, NuDataFrame};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
+
-    Value,
-};
 use polars::prelude::UniqueKeepStrategy;
 
-use crate::values::CustomValueSupport;
-use crate::PolarsPlugin;
-
-use super::super::values::utils::convert_columns_string;
-use super::super::values::{Column, NuDataFrame};
-
 #[derive(Clone)]
 pub struct DropDuplicates;
 
-impl PluginCommand for DropDuplicates {
+impl Command for DropDuplicates {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars drop-duplicates"
+        "dfr drop-duplicates"
     }
 
     fn usage(&self) -> &str {
@@ -48,7 +38,7 @@ impl PluginCommand for DropDuplicates {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "drop duplicates",
-            example: "[[a b]; [1 2] [3 4] [1 2]] | polars into-df | polars drop-duplicates",
+            example: "[[a b]; [1 2] [3 4] [1 2]] | dfr into-df | dfr drop-duplicates",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -71,22 +61,22 @@ impl PluginCommand for DropDuplicates {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let columns: Option<Vec<Value>> = call.opt(0)?;
+    let columns: Option<Vec<Value>> = call.opt(engine_state, stack, 0)?;
     let (subset, col_span) = match columns {
         Some(cols) => {
             let (agg_string, col_span) = convert_columns_string(cols, call.head)?;
@@ -95,18 +85,17 @@ fn command(
         None => (None, call.head),
     };
 
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
     let subset_slice = subset.as_ref().map(|cols| &cols[..]);
 
-    let keep_strategy = if call.has_flag("last")? {
+    let keep_strategy = if call.has_flag(engine_state, stack, "last")? {
         UniqueKeepStrategy::Last
     } else {
         UniqueKeepStrategy::First
     };
 
-    let polars_df = df
+    df.as_ref()
-        .as_ref()
         .unique(subset_slice, keep_strategy, None)
         .map_err(|e| ShellError::GenericError {
             error: "Error dropping duplicates".into(),
@@ -114,20 +103,17 @@ fn command(
             span: Some(col_span),
             help: None,
             inner: vec![],
-        })?;
+        })
-
+        .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
-    let df = NuDataFrame::new(df.from_lazy, polars_df);
-    df.to_pipeline_data(plugin, engine, call.head)
 }
 
 #[cfg(test)]
 mod test {
-    use crate::test::test_polars_plugin_command;
+    use super::super::super::test_dataframe::test_dataframe;
-
     use super::*;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&DropDuplicates)
+        test_dataframe(vec![Box::new(DropDuplicates {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/drop_nulls.rs

@@ -1,23 +1,12 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{utils::convert_columns_string, Column, NuDataFrame};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
-};
-
-use crate::values::CustomValueSupport;
-use crate::PolarsPlugin;
-
-use super::super::values::utils::convert_columns_string;
-use super::super::values::{Column, NuDataFrame};
 
 #[derive(Clone)]
 pub struct DropNulls;
 
-impl PluginCommand for DropNulls {
+impl Command for DropNulls {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars drop-nulls"
+        "dfr drop-nulls"
     }
 
     fn usage(&self) -> &str {
@@ -42,10 +31,10 @@ impl PluginCommand for DropNulls {
         vec![
             Example {
                 description: "drop null values in dataframe",
-                example: r#"let df = ([[a b]; [1 2] [3 0] [1 2]] | polars into-df);
+                example: r#"let df = ([[a b]; [1 2] [3 0] [1 2]] | dfr into-df);
     let res = ($df.b / $df.b);
-    let a = ($df | polars with-column $res --name res);
+    let a = ($df | dfr with-column $res --name res);
-    $a | polars drop-nulls"#,
+    $a | dfr drop-nulls"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -70,8 +59,8 @@ impl PluginCommand for DropNulls {
             },
             Example {
                 description: "drop null values in dataframe",
-                example: r#"let s = ([1 2 0 0 3 4] | polars into-df);
+                example: r#"let s = ([1 2 0 0 3 4] | dfr into-df);
-    ($s / $s) | polars drop-nulls"#,
+    ($s / $s) | dfr drop-nulls"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![Column::new(
@@ -94,24 +83,24 @@ impl PluginCommand for DropNulls {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
-    let columns: Option<Vec<Value>> = call.opt(0)?;
+    let columns: Option<Vec<Value>> = call.opt(engine_state, stack, 0)?;
 
     let (subset, col_span) = match columns {
         Some(cols) => {
@@ -123,8 +112,7 @@ fn command(
 
     let subset_slice = subset.as_ref().map(|cols| &cols[..]);
 
-    let polars_df = df
+    df.as_ref()
-        .as_ref()
         .drop_nulls(subset_slice)
         .map_err(|e| ShellError::GenericError {
             error: "Error dropping nulls".into(),
@@ -132,18 +120,18 @@ fn command(
             span: Some(col_span),
             help: None,
             inner: vec![],
-        })?;
+        })
-    let df = NuDataFrame::new(df.from_lazy, polars_df);
+        .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
-    df.to_pipeline_data(plugin, engine, call.head)
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
+    use super::super::WithColumn;
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&DropNulls)
+        test_dataframe(vec![Box::new(DropNulls {}), Box::new(WithColumn {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/dtypes.rs

@@ -0,0 +1,104 @@
+use crate::dataframe::values::{Column, NuDataFrame};
+use nu_engine::command_prelude::*;
+
+#[derive(Clone)]
+pub struct DataTypes;
+
+impl Command for DataTypes {
+    fn name(&self) -> &str {
+        "dfr dtypes"
+    }
+
+    fn usage(&self) -> &str {
+        "Show dataframe data types."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
+            .category(Category::Custom("dataframe".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Dataframe dtypes",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr dtypes",
+            result: Some(
+                NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "column".to_string(),
+                            vec![Value::test_string("a"), Value::test_string("b")],
+                        ),
+                        Column::new(
+                            "dtype".to_string(),
+                            vec![Value::test_string("i64"), Value::test_string("i64")],
+                        ),
+                    ],
+                    None,
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Span::test_data()),
+            ),
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        command(engine_state, stack, call, input)
+    }
+}
+
+fn command(
+    _engine_state: &EngineState,
+    _stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
+
+    let mut dtypes: Vec<Value> = Vec::new();
+    let names: Vec<Value> = df
+        .as_ref()
+        .get_column_names()
+        .iter()
+        .map(|v| {
+            let dtype = df
+                .as_ref()
+                .column(v)
+                .expect("using name from list of names from dataframe")
+                .dtype();
+
+            let dtype_str = dtype.to_string();
+
+            dtypes.push(Value::string(dtype_str, call.head));
+
+            Value::string(*v, call.head)
+        })
+        .collect();
+
+    let names_col = Column::new("column".to_string(), names);
+    let dtypes_col = Column::new("dtype".to_string(), dtypes);
+
+    NuDataFrame::try_from_columns(vec![names_col, dtypes_col], None)
+        .map(|df| PipelineData::Value(df.into_value(call.head), None))
+}
+
+#[cfg(test)]
+mod test {
+    use super::super::super::test_dataframe::test_dataframe;
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        test_dataframe(vec![Box::new(DataTypes {})])
+    }
+}

crates/nu-cmd-dataframe/src/dataframe/eager/dummies.rs

@@ -1,19 +1,14 @@
-use super::super::values::NuDataFrame;
+use crate::dataframe::values::NuDataFrame;
-use crate::{values::CustomValueSupport, PolarsPlugin};
+use nu_engine::command_prelude::*;
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, Type,
-};
 use polars::{prelude::*, series::Series};
 
 #[derive(Clone)]
 pub struct Dummies;
 
-impl PluginCommand for Dummies {
+impl Command for Dummies {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars dummies"
+        "dfr dummies"
     }
 
     fn usage(&self) -> &str {
@@ -34,9 +29,9 @@ impl PluginCommand for Dummies {
         vec![
             Example {
                 description: "Create new dataframe with dummy variables from a dataframe",
-                example: "[[a b]; [1 2] [3 4]] | polars into-df | polars dummies",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr dummies",
                 result: Some(
-                    NuDataFrame::try_from_series_vec(
+                    NuDataFrame::try_from_series(
                         vec![
                             Series::new("a_1", &[1_u8, 0]),
                             Series::new("a_3", &[0_u8, 1]),
@@ -51,9 +46,9 @@ impl PluginCommand for Dummies {
             },
             Example {
                 description: "Create new dataframe with dummy variables from a series",
-                example: "[1 2 2 3 3] | polars into-df | polars dummies",
+                example: "[1 2 2 3 3] | dfr into-df | dfr dummies",
                 result: Some(
-                    NuDataFrame::try_from_series_vec(
+                    NuDataFrame::try_from_series(
                         vec![
                             Series::new("0_1", &[1_u8, 0, 0, 0, 0]),
                             Series::new("0_2", &[0_u8, 1, 1, 0, 0]),
@@ -70,47 +65,43 @@ impl PluginCommand for Dummies {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let drop_first: bool = call.has_flag("drop-first")?;
+    let drop_first: bool = call.has_flag(engine_state, stack, "drop-first")?;
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
-    let polars_df =
+    df.as_ref()
-        df.as_ref()
+        .to_dummies(None, drop_first)
-            .to_dummies(None, drop_first)
+        .map_err(|e| ShellError::GenericError {
-            .map_err(|e| ShellError::GenericError {
+            error: "Error calculating dummies".into(),
-                error: "Error calculating dummies".into(),
+            msg: e.to_string(),
-                msg: e.to_string(),
+            span: Some(call.head),
-                span: Some(call.head),
+            help: Some("The only allowed column types for dummies are String or Int".into()),
-                help: Some("The only allowed column types for dummies are String or Int".into()),
+            inner: vec![],
-                inner: vec![],
+        })
-            })?;
+        .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
-
-    let df: NuDataFrame = polars_df.into();
-    df.to_pipeline_data(plugin, engine, call.head)
 }
 
 #[cfg(test)]
 mod test {
-    use crate::test::test_polars_plugin_command;
+    use super::super::super::test_dataframe::test_dataframe;
-
     use super::*;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&Dummies)
+        test_dataframe(vec![Box::new(Dummies {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/filter_with.rs

@@ -1,26 +1,14 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression, NuLazyFrame};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
+
-    Value,
-};
 use polars::prelude::LazyFrame;
 
-use crate::{
-    dataframe::values::{NuExpression, NuLazyFrame},
-    values::{cant_convert_err, CustomValueSupport, PolarsPluginObject, PolarsPluginType},
-    PolarsPlugin,
-};
-
-use super::super::values::{Column, NuDataFrame};
-
 #[derive(Clone)]
 pub struct FilterWith;
 
-impl PluginCommand for FilterWith {
+impl Command for FilterWith {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars filter-with"
+        "dfr filter-with"
     }
 
     fn usage(&self) -> &str {
@@ -45,8 +33,8 @@ impl PluginCommand for FilterWith {
         vec![
             Example {
                 description: "Filter dataframe using a bool mask",
-                example: r#"let mask = ([true false] | polars into-df);
+                example: r#"let mask = ([true false] | dfr into-df);
-    [[a b]; [1 2] [3 4]] | polars into-df | polars filter-with $mask"#,
+    [[a b]; [1 2] [3 4]] | dfr into-df | dfr filter-with $mask"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -61,7 +49,7 @@ impl PluginCommand for FilterWith {
             },
             Example {
                 description: "Filter dataframe using an expression",
-                example: "[[a b]; [1 2] [3 4]] | polars into-df | polars filter-with ((polars col a) > 1)",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr filter-with ((dfr col a) > 1)",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -79,42 +67,43 @@ impl PluginCommand for FilterWith {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let value = input.into_value(call.head)?;
+        let value = input.into_value(call.head);
-        match PolarsPluginObject::try_from_value(plugin, &value)? {
+
-            PolarsPluginObject::NuDataFrame(df) => command_eager(plugin, engine, call, df),
+        if NuLazyFrame::can_downcast(&value) {
-            PolarsPluginObject::NuLazyFrame(lazy) => command_lazy(plugin, engine, call, lazy),
+            let df = NuLazyFrame::try_from_value(value)?;
-            _ => Err(cant_convert_err(
+            command_lazy(engine_state, stack, call, df)
-                &value,
+        } else {
-                &[PolarsPluginType::NuDataFrame, PolarsPluginType::NuLazyFrame],
+            let df = NuDataFrame::try_from_value(value)?;
-            )),
+            command_eager(engine_state, stack, call, df)
         }
-        .map_err(LabeledError::from)
     }
 }
 
 fn command_eager(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     df: NuDataFrame,
 ) -> Result<PipelineData, ShellError> {
-    let mask_value: Value = call.req(0)?;
+    let mask_value: Value = call.req(engine_state, stack, 0)?;
     let mask_span = mask_value.span();
 
     if NuExpression::can_downcast(&mask_value) {
-        let expression = NuExpression::try_from_value(plugin, &mask_value)?;
+        let expression = NuExpression::try_from_value(mask_value)?;
-        let lazy = df.lazy();
+        let lazy = NuLazyFrame::new(true, df.lazy());
         let lazy = lazy.apply_with_expr(expression, LazyFrame::filter);
 
-        lazy.to_pipeline_data(plugin, engine, call.head)
+        Ok(PipelineData::Value(
+            NuLazyFrame::into_value(lazy, call.head)?,
+            None,
+        ))
     } else {
-        let mask = NuDataFrame::try_from_value_coerce(plugin, &mask_value, mask_span)?
+        let mask = NuDataFrame::try_from_value(mask_value)?.as_series(mask_span)?;
-            .as_series(mask_span)?;
         let mask = mask.bool().map_err(|e| ShellError::GenericError {
             error: "Error casting to bool".into(),
             msg: e.to_string(),
@@ -123,8 +112,7 @@ fn command_eager(
             inner: vec![],
         })?;
 
-        let polars_df = df
+        df.as_ref()
-            .as_ref()
             .filter(mask)
             .map_err(|e| ShellError::GenericError {
                 error: "Error filtering dataframe".into(),
@@ -132,31 +120,36 @@ fn command_eager(
                 span: Some(call.head),
                 help: Some("The only allowed column types for dummies are String or Int".into()),
                 inner: vec![],
-            })?;
+            })
-        let df = NuDataFrame::new(df.from_lazy, polars_df);
+            .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
-        df.to_pipeline_data(plugin, engine, call.head)
     }
 }
 
 fn command_lazy(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     lazy: NuLazyFrame,
 ) -> Result<PipelineData, ShellError> {
-    let expr: Value = call.req(0)?;
+    let expr: Value = call.req(engine_state, stack, 0)?;
-    let expr = NuExpression::try_from_value(plugin, &expr)?;
+    let expr = NuExpression::try_from_value(expr)?;
+
     let lazy = lazy.apply_with_expr(expr, LazyFrame::filter);
-    lazy.to_pipeline_data(plugin, engine, call.head)
+
+    Ok(PipelineData::Value(
+        NuLazyFrame::into_value(lazy, call.head)?,
+        None,
+    ))
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
+    use crate::dataframe::expressions::ExprCol;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&FilterWith)
+        test_dataframe(vec![Box::new(FilterWith {}), Box::new(ExprCol {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/first.rs

@@ -1,23 +1,12 @@
-use crate::{
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression};
-    values::{Column, CustomValueSupport, NuLazyFrame},
+use nu_engine::command_prelude::*;
-    PolarsPlugin,
-};
-
-use super::super::values::{NuDataFrame, NuExpression};
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
-};
 
 #[derive(Clone)]
 pub struct FirstDF;
 
-impl PluginCommand for FirstDF {
+impl Command for FirstDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars first"
+        "dfr first"
     }
 
     fn usage(&self) -> &str {
@@ -48,7 +37,7 @@ impl PluginCommand for FirstDF {
         vec![
             Example {
                 description: "Return the first row of a dataframe",
-                example: "[[a b]; [1 2] [3 4]] | polars into-df | polars first",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr first",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -63,7 +52,7 @@ impl PluginCommand for FirstDF {
             },
             Example {
                 description: "Return the first two rows of a dataframe",
-                example: "[[a b]; [1 2] [3 4]] | polars into-df | polars first 2",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr first 2",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -84,7 +73,7 @@ impl PluginCommand for FirstDF {
             },
             Example {
                 description: "Creates a first expression from a column",
-                example: "polars col a | polars first",
+                example: "dfr col a | dfr first",
                 result: None,
             },
         ]
@@ -92,47 +81,64 @@ impl PluginCommand for FirstDF {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let value = input.into_value(call.head)?;
+        let value = input.into_value(call.head);
-        if NuDataFrame::can_downcast(&value) || NuLazyFrame::can_downcast(&value) {
+        if NuDataFrame::can_downcast(&value) {
-            let df = NuDataFrame::try_from_value_coerce(plugin, &value, call.head)?;
+            let df = NuDataFrame::try_from_value(value)?;
-            command(plugin, engine, call, df).map_err(|e| e.into())
+            command(engine_state, stack, call, df)
         } else {
-            let expr = NuExpression::try_from_value(plugin, &value)?;
+            let expr = NuExpression::try_from_value(value)?;
             let expr: NuExpression = expr.into_polars().first().into();
 
-            expr.to_pipeline_data(plugin, engine, call.head)
+            Ok(PipelineData::Value(
-                .map_err(LabeledError::from)
+                NuExpression::into_value(expr, call.head),
+                None,
+            ))
         }
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     df: NuDataFrame,
 ) -> Result<PipelineData, ShellError> {
-    let rows: Option<usize> = call.opt(0)?;
+    let rows: Option<usize> = call.opt(engine_state, stack, 0)?;
     let rows = rows.unwrap_or(1);
 
     let res = df.as_ref().head(Some(rows));
-    let res = NuDataFrame::new(false, res);
+    Ok(PipelineData::Value(
-
+        NuDataFrame::dataframe_into_value(res, call.head),
-    res.to_pipeline_data(plugin, engine, call.head)
+        None,
+    ))
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::{build_test_engine_state, test_dataframe_example};
     use super::*;
-    use crate::test::test_polars_plugin_command;
+    use crate::dataframe::lazy::aggregate::LazyAggregate;
+    use crate::dataframe::lazy::groupby::ToLazyGroupBy;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples_dataframe() {
-        test_polars_plugin_command(&FirstDF)
+        let mut engine_state = build_test_engine_state(vec![Box::new(FirstDF {})]);
+        test_dataframe_example(&mut engine_state, &FirstDF.examples()[0]);
+        test_dataframe_example(&mut engine_state, &FirstDF.examples()[1]);
+    }
+
+    #[test]
+    fn test_examples_expression() {
+        let mut engine_state = build_test_engine_state(vec![
+            Box::new(FirstDF {}),
+            Box::new(LazyAggregate {}),
+            Box::new(ToLazyGroupBy {}),
+        ]);
+        test_dataframe_example(&mut engine_state, &FirstDF.examples()[2]);
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/get.rs

@@ -1,23 +1,12 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{utils::convert_columns_string, Column, NuDataFrame};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
-};
-
-use crate::{
-    dataframe::values::utils::convert_columns_string, values::CustomValueSupport, PolarsPlugin,
-};
-
-use super::super::values::{Column, NuDataFrame};
 
 #[derive(Clone)]
 pub struct GetDF;
 
-impl PluginCommand for GetDF {
+impl Command for GetDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars get"
+        "dfr get"
     }
 
     fn usage(&self) -> &str {
@@ -37,7 +26,7 @@ impl PluginCommand for GetDF {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Returns the selected column",
-            example: "[[a b]; [1 2] [3 4]] | polars into-df | polars get a",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr get a",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![Column::new(
@@ -54,28 +43,27 @@ impl PluginCommand for GetDF {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let columns: Vec<Value> = call.rest(0)?;
+    let columns: Vec<Value> = call.rest(engine_state, stack, 0)?;
     let (col_string, col_span) = convert_columns_string(columns, call.head)?;
 
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
-    let df = df
+    df.as_ref()
-        .as_ref()
         .select(col_string)
         .map_err(|e| ShellError::GenericError {
             error: "Error selecting columns".into(),
@@ -83,19 +71,17 @@ fn command(
             span: Some(col_span),
             help: None,
             inner: vec![],
-        })?;
+        })
-    let df = NuDataFrame::new(false, df);
+        .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
-    df.to_pipeline_data(plugin, engine, call.head)
 }
 
 #[cfg(test)]
 mod test {
-    use crate::test::test_polars_plugin_command;
+    use super::super::super::test_dataframe::test_dataframe;
-
     use super::*;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&GetDF)
+        test_dataframe(vec![Box::new(GetDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/last.rs

@@ -1,23 +1,12 @@
-use crate::{
+use crate::dataframe::values::{utils::DEFAULT_ROWS, Column, NuDataFrame, NuExpression};
-    values::{Column, CustomValueSupport, NuLazyFrame},
+use nu_engine::command_prelude::*;
-    PolarsPlugin,
-};
-
-use super::super::values::{utils::DEFAULT_ROWS, NuDataFrame, NuExpression};
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
-};
 
 #[derive(Clone)]
 pub struct LastDF;
 
-impl PluginCommand for LastDF {
+impl Command for LastDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars last"
+        "dfr last"
     }
 
     fn usage(&self) -> &str {
@@ -44,7 +33,7 @@ impl PluginCommand for LastDF {
         vec![
             Example {
                 description: "Create new dataframe with last rows",
-                example: "[[a b]; [1 2] [3 4]] | polars into-df | polars last 1",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr last 1",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -59,7 +48,7 @@ impl PluginCommand for LastDF {
             },
             Example {
                 description: "Creates a last expression from a column",
-                example: "polars col a | polars last",
+                example: "dfr col a | dfr last",
                 result: None,
             },
         ]
@@ -67,47 +56,63 @@ impl PluginCommand for LastDF {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let value = input.into_value(call.head)?;
+        let value = input.into_value(call.head);
-        if NuDataFrame::can_downcast(&value) || NuLazyFrame::can_downcast(&value) {
+        if NuDataFrame::can_downcast(&value) {
-            let df = NuDataFrame::try_from_value_coerce(plugin, &value, call.head)?;
+            let df = NuDataFrame::try_from_value(value)?;
-            command(plugin, engine, call, df).map_err(|e| e.into())
+            command(engine_state, stack, call, df)
         } else {
-            let expr = NuExpression::try_from_value(plugin, &value)?;
+            let expr = NuExpression::try_from_value(value)?;
             let expr: NuExpression = expr.into_polars().last().into();
 
-            expr.to_pipeline_data(plugin, engine, call.head)
+            Ok(PipelineData::Value(
-                .map_err(LabeledError::from)
+                NuExpression::into_value(expr, call.head),
+                None,
+            ))
         }
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     df: NuDataFrame,
 ) -> Result<PipelineData, ShellError> {
-    let rows: Option<usize> = call.opt(0)?;
+    let rows: Option<usize> = call.opt(engine_state, stack, 0)?;
     let rows = rows.unwrap_or(DEFAULT_ROWS);
 
     let res = df.as_ref().tail(Some(rows));
-    let res = NuDataFrame::new(false, res);
+    Ok(PipelineData::Value(
-    res.to_pipeline_data(plugin, engine, call.head)
+        NuDataFrame::dataframe_into_value(res, call.head),
+        None,
+    ))
 }
 
 #[cfg(test)]
 mod test {
-    use crate::test::test_polars_plugin_command;
+    use super::super::super::test_dataframe::{build_test_engine_state, test_dataframe_example};
-
     use super::*;
+    use crate::dataframe::lazy::aggregate::LazyAggregate;
+    use crate::dataframe::lazy::groupby::ToLazyGroupBy;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples_dataframe() {
-        test_polars_plugin_command(&LastDF)
+        let mut engine_state = build_test_engine_state(vec![Box::new(LastDF {})]);
+        test_dataframe_example(&mut engine_state, &LastDF.examples()[0]);
+    }
+
+    #[test]
+    fn test_examples_expression() {
+        let mut engine_state = build_test_engine_state(vec![
+            Box::new(LastDF {}),
+            Box::new(LazyAggregate {}),
+            Box::new(ToLazyGroupBy {}),
+        ]);
+        test_dataframe_example(&mut engine_state, &LastDF.examples()[1]);
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/list.rs

@@ -0,0 +1,68 @@
+use crate::dataframe::values::NuDataFrame;
+use nu_engine::command_prelude::*;
+
+#[derive(Clone)]
+pub struct ListDF;
+
+impl Command for ListDF {
+    fn name(&self) -> &str {
+        "dfr ls"
+    }
+
+    fn usage(&self) -> &str {
+        "Lists stored dataframes."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name()).category(Category::Custom("dataframe".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Creates a new dataframe and shows it in the dataframe list",
+            example: r#"let test = ([[a b];[1 2] [3 4]] | dfr into-df);
+    ls"#,
+            result: None,
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let mut vals: Vec<(String, Value)> = vec![];
+
+        for overlay_frame in engine_state.active_overlays(&[]) {
+            for var in &overlay_frame.vars {
+                if let Ok(value) = stack.get_var(*var.1, call.head) {
+                    let name = String::from_utf8_lossy(var.0).to_string();
+                    vals.push((name, value));
+                }
+            }
+        }
+
+        let vals = vals
+            .into_iter()
+            .filter_map(|(name, value)| {
+                NuDataFrame::try_from_value(value).ok().map(|df| (name, df))
+            })
+            .map(|(name, df)| {
+                Value::record(
+                    record! {
+                        "name" => Value::string(name, call.head),
+                        "columns" => Value::int(df.as_ref().width() as i64, call.head),
+                        "rows" => Value::int(df.as_ref().height() as i64, call.head),
+                    },
+                    call.head,
+                )
+            })
+            .collect::<Vec<Value>>();
+
+        let list = Value::list(vals, call.head);
+
+        Ok(list.into_pipeline_data())
+    }
+}

crates/nu-cmd-dataframe/src/dataframe/eager/melt.rs

@@ -1,23 +1,12 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{utils::convert_columns_string, Column, NuDataFrame};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, Spanned,
-    SyntaxShape, Type, Value,
-};
-
-use crate::{
-    dataframe::values::utils::convert_columns_string, values::CustomValueSupport, PolarsPlugin,
-};
-
-use super::super::values::{Column, NuDataFrame};
 
 #[derive(Clone)]
 pub struct MeltDF;
 
-impl PluginCommand for MeltDF {
+impl Command for MeltDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars melt"
+        "dfr melt"
     }
 
     fn usage(&self) -> &str {
@@ -61,7 +50,7 @@ impl PluginCommand for MeltDF {
         vec![Example {
             description: "melt dataframe",
             example:
-                "[[a b c d]; [x 1 4 a] [y 2 5 b] [z 3 6 c]] | polars into-df | polars melt -c [b c] -v [a d]",
+                "[[a b c d]; [x 1 4 a] [y 2 5 b] [z 3 6 c]] | dfr into-df | dfr melt -c [b c] -v [a d]",
             result: Some(
                 NuDataFrame::try_from_columns(vec![
                     Column::new(
@@ -117,31 +106,36 @@ impl PluginCommand for MeltDF {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let id_col: Vec<Value> = call.get_flag("columns")?.expect("required value");
+    let id_col: Vec<Value> = call
-    let val_col: Vec<Value> = call.get_flag("values")?.expect("required value");
+        .get_flag(engine_state, stack, "columns")?
+        .expect("required value");
+    let val_col: Vec<Value> = call
+        .get_flag(engine_state, stack, "values")?
+        .expect("required value");
 
-    let value_name: Option<Spanned<String>> = call.get_flag("value-name")?;
+    let value_name: Option<Spanned<String>> = call.get_flag(engine_state, stack, "value-name")?;
-    let variable_name: Option<Spanned<String>> = call.get_flag("variable-name")?;
+    let variable_name: Option<Spanned<String>> =
+        call.get_flag(engine_state, stack, "variable-name")?;
 
     let (id_col_string, id_col_span) = convert_columns_string(id_col, call.head)?;
     let (val_col_string, val_col_span) = convert_columns_string(val_col, call.head)?;
 
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
     check_column_datatypes(df.as_ref(), &id_col_string, id_col_span)?;
     check_column_datatypes(df.as_ref(), &val_col_string, val_col_span)?;
@@ -179,8 +173,10 @@ fn command(
             })?;
     }
 
-    let res = NuDataFrame::new(false, res);
+    Ok(PipelineData::Value(
-    res.to_pipeline_data(plugin, engine, call.head)
+        NuDataFrame::dataframe_into_value(res, call.head),
+        None,
+    ))
 }
 
 fn check_column_datatypes<T: AsRef<str>>(
@@ -242,12 +238,11 @@ fn check_column_datatypes<T: AsRef<str>>(
 
 #[cfg(test)]
 mod test {
-    use crate::test::test_polars_plugin_command;
+    use super::super::super::test_dataframe::test_dataframe;
-
     use super::*;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&MeltDF)
+        test_dataframe(vec![Box::new(MeltDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/mod.rs

@@ -4,11 +4,13 @@ mod columns;
 mod drop;
 mod drop_duplicates;
 mod drop_nulls;
+mod dtypes;
 mod dummies;
 mod filter_with;
 mod first;
 mod get;
 mod last;
+mod list;
 mod melt;
 mod open;
 mod query_df;
@@ -30,7 +32,7 @@ mod to_nu;
 mod to_parquet;
 mod with_column;
 
-use crate::PolarsPlugin;
+use nu_protocol::engine::StateWorkingSet;
 
 pub use self::open::OpenDataFrame;
 pub use append::AppendDF;
@@ -39,17 +41,18 @@ pub use columns::ColumnsDF;
 pub use drop::DropDF;
 pub use drop_duplicates::DropDuplicates;
 pub use drop_nulls::DropNulls;
+pub use dtypes::DataTypes;
 pub use dummies::Dummies;
 pub use filter_with::FilterWith;
 pub use first::FirstDF;
 pub use get::GetDF;
 pub use last::LastDF;
+pub use list::ListDF;
 pub use melt::MeltDF;
-use nu_plugin::PluginCommand;
 pub use query_df::QueryDf;
 pub use rename::RenameDF;
 pub use sample::SampleDF;
-pub use schema::SchemaCmd;
+pub use schema::SchemaDF;
 pub use shape::ShapeDF;
 pub use slice::SliceDF;
 pub use sql_context::SQLContext;
@@ -64,36 +67,48 @@ pub use to_nu::ToNu;
 pub use to_parquet::ToParquet;
 pub use with_column::WithColumn;
 
-pub(crate) fn eager_commands() -> Vec<Box<dyn PluginCommand<Plugin = PolarsPlugin>>> {
+pub fn add_eager_decls(working_set: &mut StateWorkingSet) {
-    vec![
+    macro_rules! bind_command {
-        Box::new(AppendDF),
+            ( $command:expr ) => {
-        Box::new(CastDF),
+                working_set.add_decl(Box::new($command));
-        Box::new(ColumnsDF),
+            };
-        Box::new(DropDF),
+            ( $( $command:expr ),* ) => {
-        Box::new(DropDuplicates),
+                $( working_set.add_decl(Box::new($command)); )*
-        Box::new(DropNulls),
+            };
-        Box::new(Dummies),
+        }
-        Box::new(FilterWith),
+
-        Box::new(GetDF),
+    // Dataframe commands
-        Box::new(OpenDataFrame),
+    bind_command!(
-        Box::new(MeltDF),
+        AppendDF,
-        Box::new(Summary),
+        CastDF,
-        Box::new(FirstDF),
+        ColumnsDF,
-        Box::new(LastDF),
+        DataTypes,
-        Box::new(RenameDF),
+        Summary,
-        Box::new(SampleDF),
+        DropDF,
-        Box::new(ShapeDF),
+        DropDuplicates,
-        Box::new(SliceDF),
+        DropNulls,
-        Box::new(SchemaCmd),
+        Dummies,
-        Box::new(TakeDF),
+        FilterWith,
-        Box::new(ToNu),
+        FirstDF,
-        Box::new(ToArrow),
+        GetDF,
-        Box::new(ToAvro),
+        LastDF,
-        Box::new(ToDataFrame),
+        ListDF,
-        Box::new(ToCSV),
+        MeltDF,
-        Box::new(ToJsonLines),
+        OpenDataFrame,
-        Box::new(ToParquet),
+        QueryDf,
-        Box::new(QueryDf),
+        RenameDF,
-        Box::new(WithColumn),
+        SampleDF,
-    ]
+        SchemaDF,
+        ShapeDF,
+        SliceDF,
+        TakeDF,
+        ToArrow,
+        ToAvro,
+        ToCSV,
+        ToDataFrame,
+        ToNu,
+        ToParquet,
+        ToJsonLines,
+        WithColumn
+    );
 }

crates/nu-cmd-dataframe/src/dataframe/eager/open.rs

@@ -1,38 +1,19 @@
-use crate::{
+use crate::dataframe::values::{NuDataFrame, NuLazyFrame, NuSchema};
-    dataframe::values::NuSchema,
+use nu_engine::command_prelude::*;
-    values::{CustomValueSupport, NuLazyFrame},
-    PolarsPlugin,
-};
-use nu_path::expand_path_with;
-
-use super::super::values::NuDataFrame;
-use nu_plugin::PluginCommand;
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, Spanned,
-    SyntaxShape, Type, Value,
-};
-
-use std::{
-    fs::File,
-    io::BufReader,
-    path::{Path, PathBuf},
-};
 
 use polars::prelude::{
     CsvEncoding, CsvReader, IpcReader, JsonFormat, JsonReader, LazyCsvReader, LazyFileListReader,
-    LazyFrame, ParquetReader, ScanArgsIpc, ScanArgsParquet, SerReader,
+    LazyFrame, ParallelStrategy, ParquetReader, ScanArgsIpc, ScanArgsParquet, SerReader,
 };
-
+use polars_io::avro::AvroReader;
-use polars_io::{avro::AvroReader, prelude::ParallelStrategy, HiveOptions};
+use std::{fs::File, io::BufReader, path::PathBuf};
 
 #[derive(Clone)]
 pub struct OpenDataFrame;
 
-impl PluginCommand for OpenDataFrame {
+impl Command for OpenDataFrame {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars open"
+        "dfr open"
     }
 
     fn usage(&self) -> &str {
@@ -95,76 +76,70 @@ impl PluginCommand for OpenDataFrame {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Takes a file name and creates a dataframe",
-            example: "polars open test.csv",
+            example: "dfr open test.csv",
             result: None,
         }]
     }
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &nu_plugin::EngineInterface,
+        stack: &mut Stack,
-        call: &nu_plugin::EvaluatedCall,
+        call: &Call,
-        _input: nu_protocol::PipelineData,
+        _input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call).map_err(|e| e.into())
+        command(engine_state, stack, call)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &nu_plugin::EngineInterface,
+    stack: &mut Stack,
-    call: &nu_plugin::EvaluatedCall,
+    call: &Call,
 ) -> Result<PipelineData, ShellError> {
-    let spanned_file: Spanned<PathBuf> = call.req(0)?;
+    let file: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
-    let file_path = expand_path_with(&spanned_file.item, engine.get_current_dir()?, true);
-    let file_span = spanned_file.span;
 
-    let type_option: Option<Spanned<String>> = call.get_flag("type")?;
+    let type_option: Option<Spanned<String>> = call.get_flag(engine_state, stack, "type")?;
 
     let type_id = match &type_option {
         Some(ref t) => Some((t.item.to_owned(), "Invalid type", t.span)),
-        None => file_path.extension().map(|e| {
+        None => file.item.extension().map(|e| {
             (
                 e.to_string_lossy().into_owned(),
                 "Invalid extension",
-                spanned_file.span,
+                file.span,
             )
         }),
     };
 
     match type_id {
         Some((e, msg, blamed)) => match e.as_str() {
-            "csv" | "tsv" => from_csv(plugin, engine, call, &file_path, file_span),
+            "csv" | "tsv" => from_csv(engine_state, stack, call),
-            "parquet" | "parq" => from_parquet(plugin, engine, call, &file_path, file_span),
+            "parquet" | "parq" => from_parquet(engine_state, stack, call),
-            "ipc" | "arrow" => from_ipc(plugin, engine, call, &file_path, file_span),
+            "ipc" | "arrow" => from_ipc(engine_state, stack, call),
-            "json" => from_json(plugin, engine, call, &file_path, file_span),
+            "json" => from_json(engine_state, stack, call),
-            "jsonl" => from_jsonl(plugin, engine, call, &file_path, file_span),
+            "jsonl" => from_jsonl(engine_state, stack, call),
-            "avro" => from_avro(plugin, engine, call, &file_path, file_span),
+            "avro" => from_avro(engine_state, stack, call),
             _ => Err(ShellError::FileNotFoundCustom {
-                msg: format!(
+                msg: format!("{msg}. Supported values: csv, tsv, parquet, ipc, arrow, json"),
-                    "{msg}. Supported values: csv, tsv, parquet, ipc, arrow, json, jsonl, avro"
-                ),
                 span: blamed,
             }),
         },
         None => Err(ShellError::FileNotFoundCustom {
             msg: "File without extension".into(),
-            span: spanned_file.span,
+            span: file.span,
         }),
     }
     .map(|value| PipelineData::Value(value, None))
 }
 
 fn from_parquet(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &nu_plugin::EngineInterface,
+    stack: &mut Stack,
-    call: &nu_plugin::EvaluatedCall,
+    call: &Call,
-    file_path: &Path,
-    file_span: Span,
 ) -> Result<Value, ShellError> {
-    if call.has_flag("lazy")? {
+    if call.has_flag(engine_state, stack, "lazy")? {
-        let file: String = call.req(0)?;
+        let file: String = call.req(engine_state, stack, 0)?;
         let args = ScanArgsParquet {
             n_rows: None,
             cache: true,
@@ -174,7 +149,7 @@ fn from_parquet(
             low_memory: false,
             cloud_options: None,
             use_statistics: false,
-            hive_options: HiveOptions::default(),
+            hive_partitioning: false,
         };
 
         let df: NuLazyFrame = LazyFrame::scan_parquet(file, args)
@@ -187,14 +162,15 @@ fn from_parquet(
             })?
             .into();
 
-        df.cache_and_to_value(plugin, engine, call.head)
+        df.into_value(call.head)
     } else {
-        let columns: Option<Vec<String>> = call.get_flag("columns")?;
+        let file: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
+        let columns: Option<Vec<String>> = call.get_flag(engine_state, stack, "columns")?;
 
-        let r = File::open(file_path).map_err(|e| ShellError::GenericError {
+        let r = File::open(&file.item).map_err(|e| ShellError::GenericError {
             error: "Error opening file".into(),
             msg: e.to_string(),
-            span: Some(file_span),
+            span: Some(file.span),
             help: None,
             inner: vec![],
         })?;
@@ -216,23 +192,22 @@ fn from_parquet(
             })?
             .into();
 
-        df.cache_and_to_value(plugin, engine, call.head)
+        Ok(df.into_value(call.head))
     }
 }
 
 fn from_avro(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &nu_plugin::EngineInterface,
+    stack: &mut Stack,
-    call: &nu_plugin::EvaluatedCall,
+    call: &Call,
-    file_path: &Path,
-    file_span: Span,
 ) -> Result<Value, ShellError> {
-    let columns: Option<Vec<String>> = call.get_flag("columns")?;
+    let file: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
+    let columns: Option<Vec<String>> = call.get_flag(engine_state, stack, "columns")?;
 
-    let r = File::open(file_path).map_err(|e| ShellError::GenericError {
+    let r = File::open(&file.item).map_err(|e| ShellError::GenericError {
         error: "Error opening file".into(),
         msg: e.to_string(),
-        span: Some(file_span),
+        span: Some(file.span),
         help: None,
         inner: vec![],
     })?;
@@ -254,25 +229,22 @@ fn from_avro(
         })?
         .into();
 
-    df.cache_and_to_value(plugin, engine, call.head)
+    Ok(df.into_value(call.head))
 }
 
 fn from_ipc(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &nu_plugin::EngineInterface,
+    stack: &mut Stack,
-    call: &nu_plugin::EvaluatedCall,
+    call: &Call,
-    file_path: &Path,
-    file_span: Span,
 ) -> Result<Value, ShellError> {
-    if call.has_flag("lazy")? {
+    if call.has_flag(engine_state, stack, "lazy")? {
-        let file: String = call.req(0)?;
+        let file: String = call.req(engine_state, stack, 0)?;
         let args = ScanArgsIpc {
             n_rows: None,
             cache: true,
             rechunk: false,
             row_index: None,
-            memory_map: true,
+            memmap: true,
-            cloud_options: None,
         };
 
         let df: NuLazyFrame = LazyFrame::scan_ipc(file, args)
@@ -285,14 +257,15 @@ fn from_ipc(
             })?
             .into();
 
-        df.cache_and_to_value(plugin, engine, call.head)
+        df.into_value(call.head)
     } else {
-        let columns: Option<Vec<String>> = call.get_flag("columns")?;
+        let file: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
+        let columns: Option<Vec<String>> = call.get_flag(engine_state, stack, "columns")?;
 
-        let r = File::open(file_path).map_err(|e| ShellError::GenericError {
+        let r = File::open(&file.item).map_err(|e| ShellError::GenericError {
             error: "Error opening file".into(),
             msg: e.to_string(),
-            span: Some(file_span),
+            span: Some(file.span),
             help: None,
             inner: vec![],
         })?;
@@ -314,26 +287,25 @@ fn from_ipc(
             })?
             .into();
 
-        df.cache_and_to_value(plugin, engine, call.head)
+        Ok(df.into_value(call.head))
     }
 }
 
 fn from_json(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &nu_plugin::EngineInterface,
+    stack: &mut Stack,
-    call: &nu_plugin::EvaluatedCall,
+    call: &Call,
-    file_path: &Path,
-    file_span: Span,
 ) -> Result<Value, ShellError> {
-    let file = File::open(file_path).map_err(|e| ShellError::GenericError {
+    let file: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
+    let file = File::open(&file.item).map_err(|e| ShellError::GenericError {
         error: "Error opening file".into(),
         msg: e.to_string(),
-        span: Some(file_span),
+        span: Some(file.span),
         help: None,
         inner: vec![],
     })?;
     let maybe_schema = call
-        .get_flag("schema")?
+        .get_flag(engine_state, stack, "schema")?
         .map(|schema| NuSchema::try_from(&schema))
         .transpose()?;
 
@@ -356,25 +328,24 @@ fn from_json(
         })?
         .into();
 
-    df.cache_and_to_value(plugin, engine, call.head)
+    Ok(df.into_value(call.head))
 }
 
 fn from_jsonl(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &nu_plugin::EngineInterface,
+    stack: &mut Stack,
-    call: &nu_plugin::EvaluatedCall,
+    call: &Call,
-    file_path: &Path,
-    file_span: Span,
 ) -> Result<Value, ShellError> {
-    let infer_schema: Option<usize> = call.get_flag("infer-schema")?;
+    let infer_schema: Option<usize> = call.get_flag(engine_state, stack, "infer-schema")?;
     let maybe_schema = call
-        .get_flag("schema")?
+        .get_flag(engine_state, stack, "schema")?
         .map(|schema| NuSchema::try_from(&schema))
         .transpose()?;
-    let file = File::open(file_path).map_err(|e| ShellError::GenericError {
+    let file: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
+    let file = File::open(&file.item).map_err(|e| ShellError::GenericError {
         error: "Error opening file".into(),
         msg: e.to_string(),
-        span: Some(file_span),
+        span: Some(file.span),
         help: None,
         inner: vec![],
     })?;
@@ -400,29 +371,28 @@ fn from_jsonl(
         })?
         .into();
 
-    df.cache_and_to_value(plugin, engine, call.head)
+    Ok(df.into_value(call.head))
 }
 
 fn from_csv(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &nu_plugin::EngineInterface,
+    stack: &mut Stack,
-    call: &nu_plugin::EvaluatedCall,
+    call: &Call,
-    file_path: &Path,
-    file_span: Span,
 ) -> Result<Value, ShellError> {
-    let delimiter: Option<Spanned<String>> = call.get_flag("delimiter")?;
+    let delimiter: Option<Spanned<String>> = call.get_flag(engine_state, stack, "delimiter")?;
-    let no_header: bool = call.has_flag("no-header")?;
+    let no_header: bool = call.has_flag(engine_state, stack, "no-header")?;
-    let infer_schema: Option<usize> = call.get_flag("infer-schema")?;
+    let infer_schema: Option<usize> = call.get_flag(engine_state, stack, "infer-schema")?;
-    let skip_rows: Option<usize> = call.get_flag("skip-rows")?;
+    let skip_rows: Option<usize> = call.get_flag(engine_state, stack, "skip-rows")?;
-    let columns: Option<Vec<String>> = call.get_flag("columns")?;
+    let columns: Option<Vec<String>> = call.get_flag(engine_state, stack, "columns")?;
 
     let maybe_schema = call
-        .get_flag("schema")?
+        .get_flag(engine_state, stack, "schema")?
         .map(|schema| NuSchema::try_from(&schema))
         .transpose()?;
 
-    if call.has_flag("lazy")? {
+    if call.has_flag(engine_state, stack, "lazy")? {
-        let csv_reader = LazyCsvReader::new(file_path);
+        let file: String = call.req(engine_state, stack, 0)?;
+        let csv_reader = LazyCsvReader::new(file);
 
         let csv_reader = match delimiter {
             None => csv_reader,
@@ -473,13 +443,14 @@ fn from_csv(
             })?
             .into();
 
-        df.cache_and_to_value(plugin, engine, call.head)
+        df.into_value(call.head)
     } else {
-        let csv_reader = CsvReader::from_path(file_path)
+        let file: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
+        let csv_reader = CsvReader::from_path(&file.item)
             .map_err(|e| ShellError::GenericError {
                 error: "Error creating CSV reader".into(),
                 msg: e.to_string(),
-                span: Some(file_span),
+                span: Some(file.span),
                 help: None,
                 inner: vec![],
             })?
@@ -539,6 +510,6 @@ fn from_csv(
             })?
             .into();
 
-        df.cache_and_to_value(plugin, engine, call.head)
+        Ok(df.into_value(call.head))
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/query_df.rs

@@ -1,13 +1,8 @@
-use super::super::values::NuDataFrame;
+use crate::dataframe::{
-use crate::dataframe::values::Column;
+    eager::SQLContext,
-use crate::dataframe::{eager::SQLContext, values::NuLazyFrame};
+    values::{Column, NuDataFrame, NuLazyFrame},
-use crate::values::CustomValueSupport;
-use crate::PolarsPlugin;
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
 };
+use nu_engine::command_prelude::*;
 
 // attribution:
 // sql_context.rs, and sql_expr.rs were copied from polars-sql. thank you.
@@ -17,11 +12,9 @@ use nu_protocol::{
 #[derive(Clone)]
 pub struct QueryDf;
 
-impl PluginCommand for QueryDf {
+impl Command for QueryDf {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars query"
+        "dfr query"
     }
 
     fn usage(&self) -> &str {
@@ -45,7 +38,7 @@ impl PluginCommand for QueryDf {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Query dataframe using SQL",
-            example: "[[a b]; [1 2] [3 4]] | polars into-df | polars query 'select a from df'",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr query 'select a from df'",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![Column::new(
@@ -62,23 +55,23 @@ impl PluginCommand for QueryDf {
 
     fn run(
         &self,
-        plugin: &PolarsPlugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let sql_query: String = call.req(0)?;
+    let sql_query: String = call.req(engine_state, stack, 0)?;
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
     let mut ctx = SQLContext::new();
     ctx.register("df", &df.df);
@@ -91,18 +84,21 @@ fn command(
             help: None,
             inner: vec![],
         })?;
-    let lazy = NuLazyFrame::new(!df.from_lazy, df_sql);
+    let lazy = NuLazyFrame::new(false, df_sql);
-    lazy.to_pipeline_data(plugin, engine, call.head)
+
+    let eager = lazy.collect(call.head)?;
+    let value = Value::custom(Box::new(eager), call.head);
+
+    Ok(PipelineData::Value(value, None))
 }
 
 #[cfg(test)]
 mod test {
-    use crate::test::test_polars_plugin_command;
+    use super::super::super::test_dataframe::test_dataframe;
-
     use super::*;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&QueryDf)
+        test_dataframe(vec![Box::new(QueryDf {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/rename.rs

@@ -1,25 +1,15 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::{
-use nu_protocol::{
+    utils::extract_strings,
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
+    values::{Column, NuDataFrame, NuLazyFrame},
-    Value,
 };
-
+use nu_engine::command_prelude::*;
-use crate::{
-    dataframe::{utils::extract_strings, values::NuLazyFrame},
-    values::{CustomValueSupport, PolarsPluginObject},
-    PolarsPlugin,
-};
-
-use super::super::values::{Column, NuDataFrame};
 
 #[derive(Clone)]
 pub struct RenameDF;
 
-impl PluginCommand for RenameDF {
+impl Command for RenameDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars rename"
+        "dfr rename"
     }
 
     fn usage(&self) -> &str {
@@ -49,7 +39,7 @@ impl PluginCommand for RenameDF {
         vec![
             Example {
                 description: "Renames a series",
-                example: "[5 6 7 8] | polars into-df | polars rename '0' new_name",
+                example: "[5 6 7 8] | dfr into-df | dfr rename '0' new_name",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![Column::new(
@@ -69,7 +59,7 @@ impl PluginCommand for RenameDF {
             },
             Example {
                 description: "Renames a dataframe column",
-                example: "[[a b]; [1 2] [3 4]] | polars into-df | polars rename a a_new",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr rename a a_new",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -90,8 +80,7 @@ impl PluginCommand for RenameDF {
             },
             Example {
                 description: "Renames two dataframe columns",
-                example:
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr rename [a b] [a_new b_new]",
-                    "[[a b]; [1 2] [3 4]] | polars into-df | polars rename [a b] [a_new b_new]",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -115,41 +104,37 @@ impl PluginCommand for RenameDF {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let value = input.into_value(call.head)?;
+        let value = input.into_value(call.head);
-        match PolarsPluginObject::try_from_value(plugin, &value).map_err(LabeledError::from)? {
+
-            PolarsPluginObject::NuDataFrame(df) => {
+        if NuLazyFrame::can_downcast(&value) {
-                command_eager(plugin, engine, call, df).map_err(LabeledError::from)
+            let df = NuLazyFrame::try_from_value(value)?;
-            }
+            command_lazy(engine_state, stack, call, df)
-            PolarsPluginObject::NuLazyFrame(lazy) => {
+        } else {
-                command_lazy(plugin, engine, call, lazy).map_err(LabeledError::from)
+            let df = NuDataFrame::try_from_value(value)?;
-            }
+            command_eager(engine_state, stack, call, df)
-            _ => Err(LabeledError::new(format!("Unsupported type: {value:?}"))
-                .with_label("Unsupported Type", call.head)),
         }
     }
 }
 
 fn command_eager(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
-    df: NuDataFrame,
+    mut df: NuDataFrame,
 ) -> Result<PipelineData, ShellError> {
-    let columns: Value = call.req(0)?;
+    let columns: Value = call.req(engine_state, stack, 0)?;
     let columns = extract_strings(columns)?;
 
-    let new_names: Value = call.req(1)?;
+    let new_names: Value = call.req(engine_state, stack, 1)?;
     let new_names = extract_strings(new_names)?;
 
-    let mut polars_df = df.to_polars();
-
     for (from, to) in columns.iter().zip(new_names.iter()) {
-        polars_df
+        df.as_mut()
             .rename(from, to)
             .map_err(|e| ShellError::GenericError {
                 error: "Error renaming".into(),
@@ -160,44 +145,42 @@ fn command_eager(
             })?;
     }
 
-    let df = NuDataFrame::new(false, polars_df);
+    Ok(PipelineData::Value(df.into_value(call.head), None))
-    df.to_pipeline_data(plugin, engine, call.head)
 }
 
 fn command_lazy(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     lazy: NuLazyFrame,
 ) -> Result<PipelineData, ShellError> {
-    let columns: Value = call.req(0)?;
+    let columns: Value = call.req(engine_state, stack, 0)?;
     let columns = extract_strings(columns)?;
 
-    let new_names: Value = call.req(1)?;
+    let new_names: Value = call.req(engine_state, stack, 1)?;
     let new_names = extract_strings(new_names)?;
 
     if columns.len() != new_names.len() {
-        let value: Value = call.req(1)?;
+        let value: Value = call.req(engine_state, stack, 1)?;
         return Err(ShellError::IncompatibleParametersSingle {
             msg: "New name list has different size to column list".into(),
             span: value.span(),
         });
     }
 
-    let lazy = lazy.to_polars();
+    let lazy = lazy.into_polars();
     let lazy: NuLazyFrame = lazy.rename(&columns, &new_names).into();
 
-    lazy.to_pipeline_data(plugin, engine, call.head)
+    Ok(PipelineData::Value(lazy.into_value(call.head)?, None))
 }
 
 #[cfg(test)]
 mod test {
-    use crate::test::test_polars_plugin_command;
+    use super::super::super::test_dataframe::test_dataframe;
-
     use super::*;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&RenameDF)
+        test_dataframe(vec![Box::new(RenameDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/sample.rs

@@ -1,23 +1,14 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::NuDataFrame;
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, Spanned,
-    SyntaxShape, Type, Value,
-};
-use polars::prelude::NamedFrom;
-use polars::series::Series;
 
-use crate::{values::CustomValueSupport, PolarsPlugin};
+use polars::{prelude::NamedFrom, series::Series};
-
-use super::super::values::{Column, NuDataFrame};
 
 #[derive(Clone)]
 pub struct SampleDF;
 
-impl PluginCommand for SampleDF {
+impl Command for SampleDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars sample"
+        "dfr sample"
     }
 
     fn usage(&self) -> &str {
@@ -57,61 +48,46 @@ impl PluginCommand for SampleDF {
         vec![
             Example {
                 description: "Sample rows from dataframe",
-                example: "[[a b]; [1 2] [3 4]] | polars into-df | polars sample --n-rows 1",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr sample --n-rows 1",
                 result: None, // No expected value because sampling is random
             },
             Example {
                 description: "Shows sample row using fraction and replace",
                 example:
-                    "[[a b]; [1 2] [3 4] [5 6]] | polars into-df | polars sample --fraction 0.5 --replace",
+                    "[[a b]; [1 2] [3 4] [5 6]] | dfr into-df | dfr sample --fraction 0.5 --replace",
                 result: None, // No expected value because sampling is random
             },
-            Example {
-                description: "Shows sample row using using predefined seed 1",
-                example:
-                    "[[a b]; [1 2] [3 4] [5 6]] | polars into-df | polars sample --seed 1 --n-rows 1",
-                result: Some(
-                    NuDataFrame::try_from_columns(
-                        vec![
-                            Column::new("a".to_string(), vec![Value::test_int(5)]),
-                            Column::new("b".to_string(), vec![Value::test_int(6)]),
-                        ],
-                        None,
-                    )
-                    .expect("should not fail")
-                    .into_value(Span::test_data()),
-                )
-            },
-
         ]
     }
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let rows: Option<Spanned<i64>> = call.get_flag("n-rows")?;
+    let rows: Option<Spanned<i64>> = call.get_flag(engine_state, stack, "n-rows")?;
-    let fraction: Option<Spanned<f64>> = call.get_flag("fraction")?;
+    let fraction: Option<Spanned<f64>> = call.get_flag(engine_state, stack, "fraction")?;
-    let seed: Option<u64> = call.get_flag::<i64>("seed")?.map(|val| val as u64);
+    let seed: Option<u64> = call
-    let replace: bool = call.has_flag("replace")?;
+        .get_flag::<i64>(engine_state, stack, "seed")?
-    let shuffle: bool = call.has_flag("shuffle")?;
+        .map(|val| val as u64);
+    let replace: bool = call.has_flag(engine_state, stack, "replace")?;
+    let shuffle: bool = call.has_flag(engine_state, stack, "shuffle")?;
 
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
-    let df = match (rows, fraction) {
+    match (rows, fraction) {
         (Some(rows), None) => df
             .as_ref()
             .sample_n(&Series::new("s", &[rows.item]), replace, shuffle, seed)
@@ -146,18 +122,6 @@ fn command(
             help: Some("Perhaps you want to use the flag -n or -f".into()),
             inner: vec![],
         }),
-    };
-    let df = NuDataFrame::new(false, df?);
-    df.to_pipeline_data(plugin, engine, call.head)
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::test::test_polars_plugin_command;
-
-    #[test]
-    fn test_examples() -> Result<(), ShellError> {
-        test_polars_plugin_command(&SampleDF)
     }
+    .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
 }

crates/nu-cmd-dataframe/src/dataframe/eager/schema.rs

@@ -1,18 +1,12 @@
-use crate::{values::PolarsPluginObject, PolarsPlugin};
+use crate::dataframe::values::NuDataFrame;
-
+use nu_engine::command_prelude::*;
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    record, Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, Type, Value,
-};
 
 #[derive(Clone)]
-pub struct SchemaCmd;
+pub struct SchemaDF;
-
-impl PluginCommand for SchemaCmd {
-    type Plugin = PolarsPlugin;
 
+impl Command for SchemaDF {
     fn name(&self) -> &str {
-        "polars schema"
+        "dfr schema"
     }
 
     fn usage(&self) -> &str {
@@ -32,7 +26,7 @@ impl PluginCommand for SchemaCmd {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Dataframe schema",
-            example: r#"[[a b]; [1 "foo"] [3 "bar"]] | polars into-df | polars schema"#,
+            example: r#"[[a b]; [1 "foo"] [3 "bar"]] | dfr into-df | dfr schema"#,
             result: Some(Value::record(
                 record! {
                     "a" => Value::string("i64", Span::test_data()),
@@ -45,44 +39,29 @@ impl PluginCommand for SchemaCmd {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        if call.has_flag("datatype-list")? {
+        if call.has_flag(engine_state, stack, "datatype-list")? {
             Ok(PipelineData::Value(datatype_list(Span::unknown()), None))
         } else {
-            command(plugin, engine, call, input).map_err(LabeledError::from)
+            command(engine_state, stack, call, input)
         }
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    _engine_state: &EngineState,
-    _engine: &EngineInterface,
+    _stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    match PolarsPluginObject::try_from_pipeline(plugin, input, call.head)? {
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
-        PolarsPluginObject::NuDataFrame(df) => {
+    let schema = df.schema();
-            let schema = df.schema();
+    let value: Value = schema.into();
-            let value: Value = schema.into();
+    Ok(PipelineData::Value(value, None))
-            Ok(PipelineData::Value(value, None))
-        }
-        PolarsPluginObject::NuLazyFrame(lazy) => {
-            let schema = lazy.schema()?;
-            let value: Value = schema.into();
-            Ok(PipelineData::Value(value, None))
-        }
-        _ => Err(ShellError::GenericError {
-            error: "Must be a dataframe or lazy dataframe".into(),
-            msg: "".into(),
-            span: Some(call.head),
-            help: None,
-            inner: vec![],
-        }),
-    }
 }
 
 fn datatype_list(span: Span) -> Value {
@@ -123,11 +102,11 @@ fn datatype_list(span: Span) -> Value {
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&SchemaCmd)
+        test_dataframe(vec![Box::new(SchemaDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/shape.rs

@@ -1,20 +1,12 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{Column, NuDataFrame};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, Type, Value,
-};
-
-use crate::{dataframe::values::Column, values::CustomValueSupport, PolarsPlugin};
-
-use super::super::values::NuDataFrame;
 
 #[derive(Clone)]
 pub struct ShapeDF;
 
-impl PluginCommand for ShapeDF {
+impl Command for ShapeDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars shape"
+        "dfr shape"
     }
 
     fn usage(&self) -> &str {
@@ -33,7 +25,7 @@ impl PluginCommand for ShapeDF {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Shows row and column shape",
-            example: "[[a b]; [1 2] [3 4]] | polars into-df | polars shape",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr shape",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -50,22 +42,22 @@ impl PluginCommand for ShapeDF {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    _engine_state: &EngineState,
-    engine: &EngineInterface,
+    _stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
     let rows = Value::int(df.as_ref().height() as i64, call.head);
 
@@ -74,17 +66,17 @@ fn command(
     let rows_col = Column::new("rows".to_string(), vec![rows]);
     let cols_col = Column::new("columns".to_string(), vec![cols]);
 
-    let df = NuDataFrame::try_from_columns(vec![rows_col, cols_col], None)?;
+    NuDataFrame::try_from_columns(vec![rows_col, cols_col], None)
-    df.to_pipeline_data(plugin, engine, call.head)
+        .map(|df| PipelineData::Value(df.into_value(call.head), None))
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ShapeDF)
+        test_dataframe(vec![Box::new(ShapeDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/slice.rs

@@ -1,21 +1,12 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{Column, NuDataFrame};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
-};
-
-use crate::{dataframe::values::Column, values::CustomValueSupport, PolarsPlugin};
-
-use super::super::values::NuDataFrame;
 
 #[derive(Clone)]
 pub struct SliceDF;
 
-impl PluginCommand for SliceDF {
+impl Command for SliceDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars slice"
+        "dfr slice"
     }
 
     fn usage(&self) -> &str {
@@ -36,7 +27,7 @@ impl PluginCommand for SliceDF {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Create new dataframe from a slice of the rows",
-            example: "[[a b]; [1 2] [3 4]] | polars into-df | polars slice 0 1",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr slice 0 1",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -53,39 +44,41 @@ impl PluginCommand for SliceDF {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let offset: i64 = call.req(0)?;
+    let offset: i64 = call.req(engine_state, stack, 0)?;
-    let size: usize = call.req(1)?;
+    let size: usize = call.req(engine_state, stack, 1)?;
 
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
     let res = df.as_ref().slice(offset, size);
-    let res = NuDataFrame::new(false, res);
 
-    res.to_pipeline_data(plugin, engine, call.head)
+    Ok(PipelineData::Value(
+        NuDataFrame::dataframe_into_value(res, call.head),
+        None,
+    ))
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&SliceDF)
+        test_dataframe(vec![Box::new(SliceDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/summary.rs

@@ -1,12 +1,6 @@
-use crate::{values::CustomValueSupport, PolarsPlugin};
+use crate::dataframe::values::{Column, NuDataFrame};
+use nu_engine::command_prelude::*;
 
-use super::super::values::{Column, NuDataFrame};
-
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
-};
 use polars::{
     chunked_array::ChunkedArray,
     prelude::{
@@ -18,11 +12,9 @@ use polars::{
 #[derive(Clone)]
 pub struct Summary;
 
-impl PluginCommand for Summary {
+impl Command for Summary {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars summary"
+        "dfr summary"
     }
 
     fn usage(&self) -> &str {
@@ -38,7 +30,7 @@ impl PluginCommand for Summary {
             )
             .named(
                 "quantiles",
-                SyntaxShape::List(Box::new(SyntaxShape::Float)),
+                SyntaxShape::Table(vec![]),
                 "provide optional quantiles",
                 Some('q'),
             )
@@ -47,7 +39,7 @@ impl PluginCommand for Summary {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "list dataframe descriptives",
-            example: "[[a b]; [1 1] [1 1]] | polars into-df | polars summary",
+            example: "[[a b]; [1 1] [1 1]] | dfr into-df | dfr summary",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -107,22 +99,22 @@ impl PluginCommand for Summary {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let quantiles: Option<Vec<Value>> = call.get_flag("quantiles")?;
+    let quantiles: Option<Vec<Value>> = call.get_flag(engine_state, stack, "quantiles")?;
     let quantiles = quantiles.map(|values| {
         values
             .iter()
@@ -175,7 +167,7 @@ fn command(
     labels.append(&mut quantiles_labels);
     labels.push(Some("max".to_string()));
 
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
     let names = ChunkedArray::<StringType>::from_slice_options("descriptor", &labels).into_series();
 
@@ -264,27 +256,24 @@ fn command(
 
     let res = head.chain(tail).collect::<Vec<Series>>();
 
-    let polars_df = DataFrame::new(res).map_err(|e| ShellError::GenericError {
+    DataFrame::new(res)
-        error: "Dataframe Error".into(),
+        .map_err(|e| ShellError::GenericError {
-        msg: e.to_string(),
+            error: "Dataframe Error".into(),
-        span: Some(call.head),
+            msg: e.to_string(),
-        help: None,
+            span: Some(call.head),
-        inner: vec![],
+            help: None,
-    })?;
+            inner: vec![],
-
+        })
-    let df = NuDataFrame::new(df.from_lazy, polars_df);
+        .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
-
-    df.to_pipeline_data(plugin, engine, call.head)
 }
 
 #[cfg(test)]
 mod test {
-    use crate::test::test_polars_plugin_command;
+    use super::super::super::test_dataframe::test_dataframe;
-
     use super::*;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&Summary)
+        test_dataframe(vec![Box::new(Summary {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/take.rs

@@ -1,22 +1,14 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{Column, NuDataFrame};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
+
-    Value,
-};
 use polars::prelude::DataType;
 
-use crate::{dataframe::values::Column, values::CustomValueSupport, PolarsPlugin};
-
-use super::super::values::NuDataFrame;
-
 #[derive(Clone)]
 pub struct TakeDF;
 
-impl PluginCommand for TakeDF {
+impl Command for TakeDF {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars take"
+        "dfr take"
     }
 
     fn usage(&self) -> &str {
@@ -41,9 +33,9 @@ impl PluginCommand for TakeDF {
         vec![
             Example {
                 description: "Takes selected rows from dataframe",
-                example: r#"let df = ([[a b]; [4 1] [5 2] [4 3]] | polars into-df);
+                example: r#"let df = ([[a b]; [4 1] [5 2] [4 3]] | dfr into-df);
-    let indices = ([0 2] | polars into-df);
+    let indices = ([0 2] | dfr into-df);
-    $df | polars take $indices"#,
+    $df | dfr take $indices"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -64,9 +56,9 @@ impl PluginCommand for TakeDF {
             },
             Example {
                 description: "Takes selected rows from series",
-                example: r#"let series = ([4 1 5 2 4 3] | polars into-df);
+                example: r#"let series = ([4 1 5 2 4 3] | dfr into-df);
-    let indices = ([0 2] | polars into-df);
+    let indices = ([0 2] | dfr into-df);
-    $series | polars take $indices"#,
+    $series | dfr take $indices"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![Column::new(
@@ -84,25 +76,24 @@ impl PluginCommand for TakeDF {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(LabeledError::from)
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let index_value: Value = call.req(0)?;
+    let index_value: Value = call.req(engine_state, stack, 0)?;
     let index_span = index_value.span();
-    let index = NuDataFrame::try_from_value_coerce(plugin, &index_value, call.head)?
+    let index = NuDataFrame::try_from_value(index_value)?.as_series(index_span)?;
-        .as_series(index_span)?;
 
     let casted = match index.dtype() {
         DataType::UInt32 | DataType::UInt64 | DataType::Int32 | DataType::Int64 => index
@@ -131,29 +122,27 @@ fn command(
         inner: vec![],
     })?;
 
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    NuDataFrame::try_from_pipeline(input, call.head).and_then(|df| {
-    let polars_df = df
+        df.as_ref()
-        .to_polars()
+            .take(indices)
-        .take(indices)
+            .map_err(|e| ShellError::GenericError {
-        .map_err(|e| ShellError::GenericError {
+                error: "Error taking values".into(),
-            error: "Error taking values".into(),
+                msg: e.to_string(),
-            msg: e.to_string(),
+                span: Some(call.head),
-            span: Some(call.head),
+                help: None,
-            help: None,
+                inner: vec![],
-            inner: vec![],
+            })
-        })?;
+            .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
-
+    })
-    let df = NuDataFrame::new(df.from_lazy, polars_df);
-    df.to_pipeline_data(plugin, engine, call.head)
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&TakeDF)
+        test_dataframe(vec![Box::new(TakeDF {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/to_arrow.rs

@@ -0,0 +1,79 @@
+use crate::dataframe::values::NuDataFrame;
+use nu_engine::command_prelude::*;
+
+use polars::prelude::{IpcWriter, SerWriter};
+use std::{fs::File, path::PathBuf};
+
+#[derive(Clone)]
+pub struct ToArrow;
+
+impl Command for ToArrow {
+    fn name(&self) -> &str {
+        "dfr to-arrow"
+    }
+
+    fn usage(&self) -> &str {
+        "Saves dataframe to arrow file."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .required("file", SyntaxShape::Filepath, "file path to save dataframe")
+            .input_output_type(Type::Custom("dataframe".into()), Type::Any)
+            .category(Category::Custom("dataframe".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Saves dataframe to arrow file",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr to-arrow test.arrow",
+            result: None,
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        command(engine_state, stack, call, input)
+    }
+}
+
+fn command(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let file_name: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
+
+    let mut df = NuDataFrame::try_from_pipeline(input, call.head)?;
+
+    let mut file = File::create(&file_name.item).map_err(|e| ShellError::GenericError {
+        error: "Error with file name".into(),
+        msg: e.to_string(),
+        span: Some(file_name.span),
+        help: None,
+        inner: vec![],
+    })?;
+
+    IpcWriter::new(&mut file)
+        .finish(df.as_mut())
+        .map_err(|e| ShellError::GenericError {
+            error: "Error saving file".into(),
+            msg: e.to_string(),
+            span: Some(file_name.span),
+            help: None,
+            inner: vec![],
+        })?;
+
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
+
+    Ok(PipelineData::Value(
+        Value::list(vec![file_value], call.head),
+        None,
+    ))
+}

crates/nu-cmd-dataframe/src/dataframe/eager/to_avro.rs

@@ -0,0 +1,109 @@
+use crate::dataframe::values::NuDataFrame;
+use nu_engine::command_prelude::*;
+
+use polars_io::{
+    avro::{AvroCompression, AvroWriter},
+    SerWriter,
+};
+use std::{fs::File, path::PathBuf};
+
+#[derive(Clone)]
+pub struct ToAvro;
+
+impl Command for ToAvro {
+    fn name(&self) -> &str {
+        "dfr to-avro"
+    }
+
+    fn usage(&self) -> &str {
+        "Saves dataframe to avro file."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .named(
+                "compression",
+                SyntaxShape::String,
+                "use compression, supports deflate or snappy",
+                Some('c'),
+            )
+            .required("file", SyntaxShape::Filepath, "file path to save dataframe")
+            .input_output_type(Type::Custom("dataframe".into()), Type::Any)
+            .category(Category::Custom("dataframe".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Saves dataframe to avro file",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr to-avro test.avro",
+            result: None,
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        command(engine_state, stack, call, input)
+    }
+}
+
+fn get_compression(call: &Call) -> Result<Option<AvroCompression>, ShellError> {
+    if let Some((compression, span)) = call
+        .get_flag_expr("compression")
+        .and_then(|e| e.as_string().map(|s| (s, e.span)))
+    {
+        match compression.as_ref() {
+            "snappy" => Ok(Some(AvroCompression::Snappy)),
+            "deflate" => Ok(Some(AvroCompression::Deflate)),
+            _ => Err(ShellError::IncorrectValue {
+                msg: "compression must be one of deflate or snappy".to_string(),
+                val_span: span,
+                call_span: span,
+            }),
+        }
+    } else {
+        Ok(None)
+    }
+}
+
+fn command(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let file_name: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
+    let compression = get_compression(call)?;
+
+    let mut df = NuDataFrame::try_from_pipeline(input, call.head)?;
+
+    let file = File::create(&file_name.item).map_err(|e| ShellError::GenericError {
+        error: "Error with file name".into(),
+        msg: e.to_string(),
+        span: Some(file_name.span),
+        help: None,
+        inner: vec![],
+    })?;
+
+    AvroWriter::new(file)
+        .with_compression(compression)
+        .finish(df.as_mut())
+        .map_err(|e| ShellError::GenericError {
+            error: "Error saving file".into(),
+            msg: e.to_string(),
+            span: Some(file_name.span),
+            help: None,
+            inner: vec![],
+        })?;
+
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
+
+    Ok(PipelineData::Value(
+        Value::list(vec![file_value], call.head),
+        None,
+    ))
+}

crates/nu-cmd-dataframe/src/dataframe/eager/to_csv.rs

@@ -1,25 +1,15 @@
-use std::{fs::File, path::PathBuf};
+use crate::dataframe::values::NuDataFrame;
+use nu_engine::command_prelude::*;
 
-use nu_path::expand_path_with;
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Spanned, SyntaxShape,
-    Type, Value,
-};
 use polars::prelude::{CsvWriter, SerWriter};
-
+use std::{fs::File, path::PathBuf};
-use crate::PolarsPlugin;
-
-use super::super::values::NuDataFrame;
 
 #[derive(Clone)]
 pub struct ToCSV;
 
-impl PluginCommand for ToCSV {
+impl Command for ToCSV {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars to-csv"
+        "dfr to-csv"
     }
 
     fn usage(&self) -> &str {
@@ -57,29 +47,28 @@ impl PluginCommand for ToCSV {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        command(plugin, engine, call, input).map_err(|e| e.into())
+        command(engine_state, stack, call, input)
     }
 }
 
 fn command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let file_name: Spanned<PathBuf> = call.req(0)?;
+    let file_name: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
-    let file_path = expand_path_with(&file_name.item, engine.get_current_dir()?, true);
+    let delimiter: Option<Spanned<String>> = call.get_flag(engine_state, stack, "delimiter")?;
-    let delimiter: Option<Spanned<String>> = call.get_flag("delimiter")?;
+    let no_header: bool = call.has_flag(engine_state, stack, "no-header")?;
-    let no_header: bool = call.has_flag("no-header")?;
 
-    let df = NuDataFrame::try_from_pipeline_coerce(plugin, input, call.head)?;
+    let mut df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
-    let mut file = File::create(file_path).map_err(|e| ShellError::GenericError {
+    let mut file = File::create(&file_name.item).map_err(|e| ShellError::GenericError {
         error: "Error with file name".into(),
         msg: e.to_string(),
         span: Some(file_name.span),
@@ -118,7 +107,7 @@ fn command(
     };
 
     writer
-        .finish(&mut df.to_polars())
+        .finish(df.as_mut())
         .map_err(|e| ShellError::GenericError {
             error: "Error writing to file".into(),
             msg: e.to_string(),
@@ -134,48 +123,3 @@ fn command(
         None,
     ))
 }
-
-#[cfg(test)]
-pub mod test {
-    use nu_plugin_test_support::PluginTest;
-    use nu_protocol::{Span, Value};
-    use uuid::Uuid;
-
-    use crate::PolarsPlugin;
-
-    #[test]
-    pub fn test_to_csv() -> Result<(), Box<dyn std::error::Error>> {
-        let tmp_dir = tempfile::tempdir()?;
-        let mut tmp_file = tmp_dir.path().to_owned();
-        tmp_file.push(format!("{}.csv", Uuid::new_v4()));
-        let tmp_file_str = tmp_file.to_str().expect("should be able to get file path");
-
-        let cmd = format!(
-            "[[a b]; [1 2] [3 4]] | polars into-df | polars to-csv {}",
-            tmp_file_str
-        );
-        println!("cmd: {}", cmd);
-        let mut plugin_test = PluginTest::new("polars", PolarsPlugin::default().into())?;
-        plugin_test.engine_state_mut().add_env_var(
-            "PWD".to_string(),
-            Value::string(
-                tmp_dir
-                    .path()
-                    .to_str()
-                    .expect("should be able to get path")
-                    .to_owned(),
-                Span::test_data(),
-            ),
-        );
-        let pipeline_data = plugin_test.eval(&cmd)?;
-
-        assert!(tmp_file.exists());
-
-        let value = pipeline_data.into_value(Span::test_data())?;
-        let list = value.as_list()?;
-        assert_eq!(list.len(), 1);
-        let msg = list.first().expect("should have a value").as_str()?;
-        assert!(msg.contains("saved"));
-        Ok(())
-    }
-}

crates/nu-cmd-dataframe/src/dataframe/eager/to_df.rs

@@ -1,28 +1,14 @@
-use crate::{
+use crate::dataframe::values::{Column, NuDataFrame, NuSchema};
-    dataframe::values::NuSchema,
+use nu_engine::command_prelude::*;
-    values::{Column, CustomValueSupport},
-    PolarsPlugin,
-};
 
-use super::super::values::NuDataFrame;
+use polars::prelude::*;
-
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, Signature, Span, SyntaxShape, Type, Value,
-};
-use polars::{
-    prelude::{AnyValue, DataType, Field, NamedFrom},
-    series::Series,
-};
 
 #[derive(Clone)]
 pub struct ToDataFrame;
 
-impl PluginCommand for ToDataFrame {
+impl Command for ToDataFrame {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars into-df"
+        "dfr into-df"
     }
 
     fn usage(&self) -> &str {
@@ -45,7 +31,7 @@ impl PluginCommand for ToDataFrame {
         vec![
             Example {
                 description: "Takes a dictionary and creates a dataframe",
-                example: "[[a b];[1 2] [3 4]] | polars into-df",
+                example: "[[a b];[1 2] [3 4]] | dfr into-df",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -66,7 +52,7 @@ impl PluginCommand for ToDataFrame {
             },
             Example {
                 description: "Takes a list of tables and creates a dataframe",
-                example: "[[1 2 a] [3 4 b] [5 6 c]] | polars into-df",
+                example: "[[1 2 a] [3 4 b] [5 6 c]] | dfr into-df",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -95,7 +81,7 @@ impl PluginCommand for ToDataFrame {
             },
             Example {
                 description: "Takes a list and creates a dataframe",
-                example: "[a b c] | polars into-df",
+                example: "[a b c] | dfr into-df",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![Column::new(
@@ -114,7 +100,7 @@ impl PluginCommand for ToDataFrame {
             },
             Example {
                 description: "Takes a list of booleans and creates a dataframe",
-                example: "[true true false] | polars into-df",
+                example: "[true true false] | dfr into-df",
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![Column::new(
@@ -133,9 +119,9 @@ impl PluginCommand for ToDataFrame {
             },
             Example {
                 description: "Convert to a dataframe and provide a schema",
-                example: "{a: 1, b: {a: [1 2 3]}, c: [a b c]}| polars into-df -s {a: u8, b: {a: list<u64>}, c: list<str>}",
+                example: "{a: 1, b: {a: [1 2 3]}, c: [a b c]}| dfr into-df -s {a: u8, b: {a: list<u64>}, c: list<str>}",
                 result: Some(
-                    NuDataFrame::try_from_series_vec(vec![
+                    NuDataFrame::try_from_series(vec![
                         Series::new("a", &[1u8]),
                         {
                             let dtype = DataType::Struct(vec![Field::new("a", DataType::List(Box::new(DataType::UInt64)))]);
@@ -157,8 +143,8 @@ impl PluginCommand for ToDataFrame {
             },
             Example {
                 description: "Convert to a dataframe and provide a schema that adds a new column",
-                example: r#"[[a b]; [1 "foo"] [2 "bar"]] | polars into-df -s {a: u8, b:str, c:i64} | polars fill-null 3"#,
+                example: r#"[[a b]; [1 "foo"] [2 "bar"]] | dfr into-df -s {a: u8, b:str, c:i64} | dfr fill-null 3"#,
-                result: Some(NuDataFrame::try_from_series_vec(vec![
+                result: Some(NuDataFrame::try_from_series(vec![
                         Series::new("a", [1u8, 2]),
                         Series::new("b", ["foo", "bar"]),
                         Series::new("c", [3i64, 3]),
@@ -172,31 +158,32 @@ impl PluginCommand for ToDataFrame {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
         let maybe_schema = call
-            .get_flag("schema")?
+            .get_flag(engine_state, stack, "schema")?
             .map(|schema| NuSchema::try_from(&schema))
             .transpose()?;
 
-        let df = NuDataFrame::try_from_iter(plugin, input.into_iter(), maybe_schema.clone())?;
+        let df = NuDataFrame::try_from_iter(input.into_iter(), maybe_schema.clone())?;
-        df.to_pipeline_data(plugin, engine, call.head)
+
-            .map_err(LabeledError::from)
+        Ok(PipelineData::Value(
+            NuDataFrame::into_value(df, call.head),
+            None,
+        ))
     }
 }
 
 #[cfg(test)]
 mod test {
-    use crate::test::test_polars_plugin_command;
+    use super::super::super::test_dataframe::test_dataframe;
-
     use super::*;
-    use nu_protocol::ShellError;
 
     #[test]
-    fn test_into_df() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ToDataFrame)
+        test_dataframe(vec![Box::new(ToDataFrame {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/to_json_lines.rs

@@ -0,0 +1,80 @@
+use crate::dataframe::values::NuDataFrame;
+use nu_engine::command_prelude::*;
+
+use polars::prelude::{JsonWriter, SerWriter};
+use std::{fs::File, io::BufWriter, path::PathBuf};
+
+#[derive(Clone)]
+pub struct ToJsonLines;
+
+impl Command for ToJsonLines {
+    fn name(&self) -> &str {
+        "dfr to-jsonl"
+    }
+
+    fn usage(&self) -> &str {
+        "Saves dataframe to a JSON lines file."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .required("file", SyntaxShape::Filepath, "file path to save dataframe")
+            .input_output_type(Type::Custom("dataframe".into()), Type::Any)
+            .category(Category::Custom("dataframe".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Saves dataframe to JSON lines file",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr to-jsonl test.jsonl",
+            result: None,
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        command(engine_state, stack, call, input)
+    }
+}
+
+fn command(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let file_name: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
+
+    let mut df = NuDataFrame::try_from_pipeline(input, call.head)?;
+
+    let file = File::create(&file_name.item).map_err(|e| ShellError::GenericError {
+        error: "Error with file name".into(),
+        msg: e.to_string(),
+        span: Some(file_name.span),
+        help: None,
+        inner: vec![],
+    })?;
+    let buf_writer = BufWriter::new(file);
+
+    JsonWriter::new(buf_writer)
+        .finish(df.as_mut())
+        .map_err(|e| ShellError::GenericError {
+            error: "Error saving file".into(),
+            msg: e.to_string(),
+            span: Some(file_name.span),
+            help: None,
+            inner: vec![],
+        })?;
+
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
+
+    Ok(PipelineData::Value(
+        Value::list(vec![file_value], call.head),
+        None,
+    ))
+}

crates/nu-cmd-dataframe/src/dataframe/eager/to_nu.rs

@@ -1,25 +1,12 @@
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use crate::dataframe::values::{NuDataFrame, NuExpression};
-use nu_protocol::{
+use nu_engine::command_prelude::*;
-    record, Category, Example, LabeledError, PipelineData, ShellError, Signature, Span,
-    SyntaxShape, Type, Value,
-};
-
-use crate::{
-    dataframe::values::NuExpression,
-    values::{CustomValueSupport, NuLazyFrame},
-    PolarsPlugin,
-};
-
-use super::super::values::NuDataFrame;
 
 #[derive(Clone)]
 pub struct ToNu;
 
-impl PluginCommand for ToNu {
+impl Command for ToNu {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars into-nu"
+        "dfr into-nu"
     }
 
     fn usage(&self) -> &str {
@@ -37,8 +24,9 @@ impl PluginCommand for ToNu {
             .switch("tail", "shows tail rows", Some('t'))
             .input_output_types(vec![
                 (Type::Custom("expression".into()), Type::Any),
-                (Type::Custom("dataframe".into()), Type::table()),
+                (Type::Custom("dataframe".into()), Type::Table(vec![])),
             ])
+            //.input_output_type(Type::Any, Type::Any)
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -62,18 +50,17 @@ impl PluginCommand for ToNu {
         vec![
             Example {
                 description: "Shows head rows from dataframe",
-                example: "[[a b]; [1 2] [3 4]] | polars into-df | polars into-nu",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr into-nu",
                 result: Some(Value::list(vec![rec_1, rec_2], Span::test_data())),
             },
             Example {
                 description: "Shows tail rows from dataframe",
-                example:
+                example: "[[a b]; [1 2] [5 6] [3 4]] | dfr into-df | dfr into-nu --tail --rows 1",
-                    "[[a b]; [1 2] [5 6] [3 4]] | polars into-df | polars into-nu --tail --rows 1",
                 result: Some(Value::list(vec![rec_3], Span::test_data())),
             },
             Example {
                 description: "Convert a col expression into a nushell value",
-                example: "polars col a | polars into-nu",
+                example: "dfr col a | dfr into-nu",
                 result: Some(Value::test_record(record! {
                     "expr" =>  Value::test_string("column"),
                     "value" => Value::test_string("a"),
@@ -84,30 +71,30 @@ impl PluginCommand for ToNu {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        _engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let value = input.into_value(call.head)?;
+        let value = input.into_value(call.head);
-        if NuDataFrame::can_downcast(&value) || NuLazyFrame::can_downcast(&value) {
+        if NuDataFrame::can_downcast(&value) {
-            dataframe_command(plugin, call, value)
+            dataframe_command(engine_state, stack, call, value)
         } else {
-            expression_command(plugin, call, value)
+            expression_command(call, value)
         }
-        .map_err(|e| e.into())
     }
 }
 
 fn dataframe_command(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    call: &EvaluatedCall,
+    stack: &mut Stack,
+    call: &Call,
     input: Value,
 ) -> Result<PipelineData, ShellError> {
-    let rows: Option<usize> = call.get_flag("rows")?;
+    let rows: Option<usize> = call.get_flag(engine_state, stack, "rows")?;
-    let tail: bool = call.has_flag("tail")?;
+    let tail: bool = call.has_flag(engine_state, stack, "tail")?;
 
-    let df = NuDataFrame::try_from_value_coerce(plugin, &input, call.head)?;
+    let df = NuDataFrame::try_from_value(input)?;
 
     let values = if tail {
         df.tail(rows, call.head)?
@@ -124,13 +111,8 @@ fn dataframe_command(
 
     Ok(PipelineData::Value(value, None))
 }
-
+fn expression_command(call: &Call, input: Value) -> Result<PipelineData, ShellError> {
-fn expression_command(
+    let expr = NuExpression::try_from_value(input)?;
-    plugin: &PolarsPlugin,
-    call: &EvaluatedCall,
-    input: Value,
-) -> Result<PipelineData, ShellError> {
-    let expr = NuExpression::try_from_value(plugin, &input)?;
     let value = expr.to_value(call.head)?;
 
     Ok(PipelineData::Value(value, None))
@@ -138,11 +120,17 @@ fn expression_command(
 
 #[cfg(test)]
 mod test {
+    use super::super::super::expressions::ExprCol;
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples_dataframe_input() {
-        test_polars_plugin_command(&ToNu)
+        test_dataframe(vec![Box::new(ToNu {})])
+    }
+
+    #[test]
+    fn test_examples_expression_input() {
+        test_dataframe(vec![Box::new(ToNu {}), Box::new(ExprCol {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/eager/to_parquet.rs

@@ -0,0 +1,79 @@
+use crate::dataframe::values::NuDataFrame;
+use nu_engine::command_prelude::*;
+
+use polars::prelude::ParquetWriter;
+use std::{fs::File, path::PathBuf};
+
+#[derive(Clone)]
+pub struct ToParquet;
+
+impl Command for ToParquet {
+    fn name(&self) -> &str {
+        "dfr to-parquet"
+    }
+
+    fn usage(&self) -> &str {
+        "Saves dataframe to parquet file."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .required("file", SyntaxShape::Filepath, "file path to save dataframe")
+            .input_output_type(Type::Custom("dataframe".into()), Type::Any)
+            .category(Category::Custom("dataframe".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Saves dataframe to parquet file",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr to-parquet test.parquet",
+            result: None,
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        command(engine_state, stack, call, input)
+    }
+}
+
+fn command(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let file_name: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
+
+    let mut df = NuDataFrame::try_from_pipeline(input, call.head)?;
+
+    let file = File::create(&file_name.item).map_err(|e| ShellError::GenericError {
+        error: "Error with file name".into(),
+        msg: e.to_string(),
+        span: Some(file_name.span),
+        help: None,
+        inner: vec![],
+    })?;
+
+    ParquetWriter::new(file)
+        .finish(df.as_mut())
+        .map_err(|e| ShellError::GenericError {
+            error: "Error saving file".into(),
+            msg: e.to_string(),
+            span: Some(file_name.span),
+            help: None,
+            inner: vec![],
+        })?;
+
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
+
+    Ok(PipelineData::Value(
+        Value::list(vec![file_value], call.head),
+        None,
+    ))
+}

crates/nu-cmd-dataframe/src/dataframe/eager/with_column.rs

@@ -1,23 +1,12 @@
-use super::super::values::{Column, NuDataFrame};
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression, NuLazyFrame};
-use crate::{
+use nu_engine::command_prelude::*;
-    dataframe::values::{NuExpression, NuLazyFrame},
-    values::{CustomValueSupport, PolarsPluginObject},
-    PolarsPlugin,
-};
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
-};
 
 #[derive(Clone)]
 pub struct WithColumn;
 
-impl PluginCommand for WithColumn {
+impl Command for WithColumn {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars with-column"
+        "dfr with-column"
     }
 
     fn usage(&self) -> &str {
@@ -44,8 +33,8 @@ impl PluginCommand for WithColumn {
             Example {
                 description: "Adds a series to the dataframe",
                 example: r#"[[a b]; [1 2] [3 4]]
-    | polars into-df
+    | dfr into-df
-    | polars with-column ([5 6] | polars into-df) --name c"#,
+    | dfr with-column ([5 6] | dfr into-df) --name c"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -71,12 +60,12 @@ impl PluginCommand for WithColumn {
             Example {
                 description: "Adds a series to the dataframe",
                 example: r#"[[a b]; [1 2] [3 4]]
-    | polars into-lazy
+    | dfr into-lazy
-    | polars with-column [
+    | dfr with-column [
-        ((polars col a) * 2 | polars as "c")
+        ((dfr col a) * 2 | dfr as "c")
-        ((polars col a) * 3 | polars as "d")
+        ((dfr col a) * 3 | dfr as "d")
       ]
-    | polars collect"#,
+    | dfr collect"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -108,55 +97,59 @@ impl PluginCommand for WithColumn {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let value = input.into_value(call.head)?;
+        let value = input.into_value(call.head);
-        match PolarsPluginObject::try_from_value(plugin, &value)? {
+
-            PolarsPluginObject::NuDataFrame(df) => command_eager(plugin, engine, call, df),
+        if NuLazyFrame::can_downcast(&value) {
-            PolarsPluginObject::NuLazyFrame(lazy) => command_lazy(plugin, engine, call, lazy),
+            let df = NuLazyFrame::try_from_value(value)?;
-            _ => Err(ShellError::CantConvert {
+            command_lazy(engine_state, stack, call, df)
+        } else if NuDataFrame::can_downcast(&value) {
+            let df = NuDataFrame::try_from_value(value)?;
+            command_eager(engine_state, stack, call, df)
+        } else {
+            Err(ShellError::CantConvert {
                 to_type: "lazy or eager dataframe".into(),
                 from_type: value.get_type().to_string(),
                 span: value.span(),
                 help: None,
-            }),
+            })
         }
-        .map_err(LabeledError::from)
     }
 }
 
 fn command_eager(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
-    df: NuDataFrame,
+    mut df: NuDataFrame,
 ) -> Result<PipelineData, ShellError> {
-    let new_column: Value = call.req(0)?;
+    let new_column: Value = call.req(engine_state, stack, 0)?;
     let column_span = new_column.span();
 
     if NuExpression::can_downcast(&new_column) {
-        let vals: Vec<Value> = call.rest(0)?;
+        let vals: Vec<Value> = call.rest(engine_state, stack, 0)?;
         let value = Value::list(vals, call.head);
-        let expressions = NuExpression::extract_exprs(plugin, value)?;
+        let expressions = NuExpression::extract_exprs(value)?;
-        let lazy = NuLazyFrame::new(true, df.lazy().to_polars().with_columns(&expressions));
+        let lazy = NuLazyFrame::new(true, df.lazy().with_columns(&expressions));
-        let df = lazy.collect(call.head)?;
-        df.to_pipeline_data(plugin, engine, call.head)
-    } else {
-        let mut other = NuDataFrame::try_from_value_coerce(plugin, &new_column, call.head)?
-            .as_series(column_span)?;
 
-        let name = match call.get_flag::<String>("name")? {
+        let df = lazy.collect(call.head)?;
+
+        Ok(PipelineData::Value(df.into_value(call.head), None))
+    } else {
+        let mut other = NuDataFrame::try_from_value(new_column)?.as_series(column_span)?;
+
+        let name = match call.get_flag::<String>(engine_state, stack, "name")? {
             Some(name) => name,
             None => other.name().to_string(),
         };
 
         let series = other.rename(&name).clone();
 
-        let mut polars_df = df.to_polars();
+        df.as_mut()
-        polars_df
             .with_column(series)
             .map_err(|e| ShellError::GenericError {
                 error: "Error adding column to dataframe".into(),
@@ -164,33 +157,47 @@ fn command_eager(
                 span: Some(column_span),
                 help: None,
                 inner: vec![],
-            })?;
+            })
-
+            .map(|df| {
-        let df = NuDataFrame::new(df.from_lazy, polars_df);
+                PipelineData::Value(
-        df.to_pipeline_data(plugin, engine, call.head)
+                    NuDataFrame::dataframe_into_value(df.clone(), call.head),
+                    None,
+                )
+            })
     }
 }
 
 fn command_lazy(
-    plugin: &PolarsPlugin,
+    engine_state: &EngineState,
-    engine: &EngineInterface,
+    stack: &mut Stack,
-    call: &EvaluatedCall,
+    call: &Call,
     lazy: NuLazyFrame,
 ) -> Result<PipelineData, ShellError> {
-    let vals: Vec<Value> = call.rest(0)?;
+    let vals: Vec<Value> = call.rest(engine_state, stack, 0)?;
     let value = Value::list(vals, call.head);
-    let expressions = NuExpression::extract_exprs(plugin, value)?;
+    let expressions = NuExpression::extract_exprs(value)?;
-    let lazy: NuLazyFrame = lazy.to_polars().with_columns(&expressions).into();
+
-    lazy.to_pipeline_data(plugin, engine, call.head)
+    let lazy: NuLazyFrame = lazy.into_polars().with_columns(&expressions).into();
+
+    Ok(PipelineData::Value(
+        NuLazyFrame::into_value(lazy, call.head)?,
+        None,
+    ))
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
+    use crate::dataframe::expressions::ExprAlias;
+    use crate::dataframe::expressions::ExprCol;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&WithColumn)
+        test_dataframe(vec![
+            Box::new(WithColumn {}),
+            Box::new(ExprAlias {}),
+            Box::new(ExprCol {}),
+        ])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/expressions/alias.rs

@@ -1,20 +1,12 @@
-use crate::{values::CustomValueSupport, PolarsPlugin};
+use crate::dataframe::values::NuExpression;
-
+use nu_engine::command_prelude::*;
-use super::super::values::NuExpression;
-
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    record, Category, Example, LabeledError, PipelineData, Signature, SyntaxShape, Type, Value,
-};
 
 #[derive(Clone)]
 pub struct ExprAlias;
 
-impl PluginCommand for ExprAlias {
+impl Command for ExprAlias {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars as"
+        "dfr as"
     }
 
     fn usage(&self) -> &str {
@@ -38,7 +30,7 @@ impl PluginCommand for ExprAlias {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Creates and alias expression",
-            example: "polars col a | polars as new_a | polars into-nu",
+            example: "dfr col a | dfr as new_a | dfr into-nu",
             result: {
                 let record = Value::test_record(record! {
                     "expr" =>  Value::test_record(record! {
@@ -59,28 +51,36 @@ impl PluginCommand for ExprAlias {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let alias: String = call.req(0)?;
+        let alias: String = call.req(engine_state, stack, 0)?;
 
-        let expr = NuExpression::try_from_pipeline(plugin, input, call.head)?;
+        let expr = NuExpression::try_from_pipeline(input, call.head)?;
         let expr: NuExpression = expr.into_polars().alias(alias.as_str()).into();
 
-        expr.to_pipeline_data(plugin, engine, call.head)
+        Ok(PipelineData::Value(
-            .map_err(LabeledError::from)
+            NuExpression::into_value(expr, call.head),
+            None,
+        ))
     }
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
+    use crate::dataframe::eager::ToNu;
+    use crate::dataframe::expressions::ExprCol;
 
     #[test]
-    fn test_examples() -> Result<(), nu_protocol::ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ExprAlias)
+        test_dataframe(vec![
+            Box::new(ExprAlias {}),
+            Box::new(ExprCol {}),
+            Box::new(ToNu {}),
+        ])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/expressions/arg_where.rs

@@ -1,22 +1,14 @@
-use crate::{
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression};
-    dataframe::values::{Column, NuDataFrame, NuExpression},
+use nu_engine::command_prelude::*;
-    values::CustomValueSupport,
+
-    PolarsPlugin,
-};
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, Signature, Span, SyntaxShape, Type, Value,
-};
 use polars::prelude::arg_where;
 
 #[derive(Clone)]
 pub struct ExprArgWhere;
 
-impl PluginCommand for ExprArgWhere {
+impl Command for ExprArgWhere {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars arg-where"
+        "dfr arg-where"
     }
 
     fn usage(&self) -> &str {
@@ -33,8 +25,8 @@ impl PluginCommand for ExprArgWhere {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Return a dataframe where the value match the expression",
-            example: "let df = ([[a b]; [one 1] [two 2] [three 3]] | polars into-df);
+            example: "let df = ([[a b]; [one 1] [two 2] [three 3]] | dfr into-df);
-    $df | polars select (polars arg-where ((polars col b) >= 2) | polars as b_arg)",
+    $df | dfr select (dfr arg-where ((dfr col b) >= 2) | dfr as b_arg)",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![Column::new(
@@ -55,26 +47,32 @@ impl PluginCommand for ExprArgWhere {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         _input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let value: Value = call.req(0)?;
+        let value: Value = call.req(engine_state, stack, 0)?;
-        let expr = NuExpression::try_from_value(plugin, &value)?;
+        let expr = NuExpression::try_from_value(value)?;
         let expr: NuExpression = arg_where(expr.into_polars()).into();
-        expr.to_pipeline_data(plugin, engine, call.head)
+
-            .map_err(LabeledError::from)
+        Ok(PipelineData::Value(expr.into_value(call.head), None))
     }
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
+    use crate::dataframe::expressions::ExprAlias;
+    use crate::dataframe::lazy::LazySelect;
 
     #[test]
-    fn test_examples() -> Result<(), nu_protocol::ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ExprArgWhere)
+        test_dataframe(vec![
+            Box::new(ExprArgWhere {}),
+            Box::new(ExprAlias {}),
+            Box::new(LazySelect {}),
+        ])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/expressions/col.rs

@@ -1,18 +1,14 @@
-use crate::{dataframe::values::NuExpression, values::CustomValueSupport, PolarsPlugin};
+use crate::dataframe::values::NuExpression;
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use nu_engine::command_prelude::*;
-use nu_protocol::{
+
-    record, Category, Example, LabeledError, PipelineData, Signature, SyntaxShape, Type, Value,
-};
 use polars::prelude::col;
 
 #[derive(Clone)]
 pub struct ExprCol;
 
-impl PluginCommand for ExprCol {
+impl Command for ExprCol {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars col"
+        "dfr col"
     }
 
     fn usage(&self) -> &str {
@@ -33,7 +29,7 @@ impl PluginCommand for ExprCol {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Creates a named column expression and converts it to a nu object",
-            example: "polars col a | polars into-nu",
+            example: "dfr col a | dfr into-nu",
             result: Some(Value::test_record(record! {
                 "expr" =>  Value::test_string("column"),
                 "value" => Value::test_string("a"),
@@ -47,25 +43,26 @@ impl PluginCommand for ExprCol {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         _input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let name: String = call.req(0)?;
+        let name: String = call.req(engine_state, stack, 0)?;
         let expr: NuExpression = col(name.as_str()).into();
-        expr.to_pipeline_data(plugin, engine, call.head)
+
-            .map_err(LabeledError::from)
+        Ok(PipelineData::Value(expr.into_value(call.head), None))
     }
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
+    use crate::dataframe::eager::ToNu;
 
     #[test]
-    fn test_examples() -> Result<(), nu_protocol::ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ExprCol)
+        test_dataframe(vec![Box::new(ExprCol {}), Box::new(ToNu {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/expressions/concat_str.rs

@@ -1,22 +1,14 @@
-use crate::{
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression};
-    dataframe::values::{Column, NuDataFrame, NuExpression},
+use nu_engine::command_prelude::*;
-    values::CustomValueSupport,
+
-    PolarsPlugin,
-};
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, Signature, Span, SyntaxShape, Type, Value,
-};
 use polars::prelude::concat_str;
 
 #[derive(Clone)]
 pub struct ExprConcatStr;
 
-impl PluginCommand for ExprConcatStr {
+impl Command for ExprConcatStr {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars concat-str"
+        "dfr concat-str"
     }
 
     fn usage(&self) -> &str {
@@ -42,8 +34,8 @@ impl PluginCommand for ExprConcatStr {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Creates a concat string expression",
-            example: r#"let df = ([[a b c]; [one two 1] [three four 2]] | polars into-df);
+            example: r#"let df = ([[a b c]; [one two 1] [three four 2]] | dfr into-df);
-    $df | polars with-column ((polars concat-str "-" [(polars col a) (polars col b) ((polars col c) * 2)]) | polars as concat)"#,
+    $df | dfr with-column ((dfr concat-str "-" [(dfr col a) (dfr col b) ((dfr col c) * 2)]) | dfr as concat)"#,
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -81,30 +73,36 @@ impl PluginCommand for ExprConcatStr {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         _input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let separator: String = call.req(0)?;
+        let separator: String = call.req(engine_state, stack, 0)?;
-        let value: Value = call.req(1)?;
+        let value: Value = call.req(engine_state, stack, 1)?;
 
-        let expressions = NuExpression::extract_exprs(plugin, value)?;
+        let expressions = NuExpression::extract_exprs(value)?;
         let expr: NuExpression = concat_str(expressions, &separator, false).into();
 
-        expr.to_pipeline_data(plugin, engine, call.head)
+        Ok(PipelineData::Value(expr.into_value(call.head), None))
-            .map_err(LabeledError::from)
     }
 }
 
 #[cfg(test)]
 mod test {
-    use crate::test::test_polars_plugin_command;
+    use super::super::super::test_dataframe::test_dataframe;
-
     use super::*;
+    use crate::dataframe::eager::WithColumn;
+    use crate::dataframe::expressions::alias::ExprAlias;
+    use crate::dataframe::expressions::col::ExprCol;
 
     #[test]
-    fn test_examples() -> Result<(), nu_protocol::ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ExprConcatStr)
+        test_dataframe(vec![
+            Box::new(ExprConcatStr {}),
+            Box::new(ExprAlias {}),
+            Box::new(ExprCol {}),
+            Box::new(WithColumn {}),
+        ])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/expressions/datepart.rs

@@ -1,16 +1,7 @@
-use super::super::values::NuExpression;
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression};
-
-use crate::{
-    dataframe::values::{Column, NuDataFrame},
-    values::CustomValueSupport,
-    PolarsPlugin,
-};
 use chrono::{DateTime, FixedOffset};
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use nu_engine::command_prelude::*;
-use nu_protocol::{
+
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, Spanned,
-    SyntaxShape, Type, Value,
-};
 use polars::{
     datatypes::{DataType, TimeUnit},
     prelude::NamedFrom,
@@ -20,11 +11,9 @@ use polars::{
 #[derive(Clone)]
 pub struct ExprDatePart;
 
-impl PluginCommand for ExprDatePart {
+impl Command for ExprDatePart {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars datepart"
+        "dfr datepart"
     }
 
     fn usage(&self) -> &str {
@@ -54,7 +43,7 @@ impl PluginCommand for ExprDatePart {
         vec![
             Example {
                 description: "Creates an expression to capture the year date part",
-                example: r#"[["2021-12-30T01:02:03.123456789"]] | polars into-df | polars as-datetime "%Y-%m-%dT%H:%M:%S.%9f" | polars with-column [(polars col datetime | polars datepart year | polars as datetime_year )]"#,
+                example: r#"[["2021-12-30T01:02:03.123456789"]] | dfr into-df | dfr as-datetime "%Y-%m-%dT%H:%M:%S.%9f" | dfr with-column [(dfr col datetime | dfr datepart year | dfr as datetime_year )]"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -69,16 +58,16 @@ impl PluginCommand for ExprDatePart {
             },
             Example {
                 description: "Creates an expression to capture multiple date parts",
-                example: r#"[["2021-12-30T01:02:03.123456789"]] | polars into-df | polars as-datetime "%Y-%m-%dT%H:%M:%S.%9f" |
+                example: r#"[["2021-12-30T01:02:03.123456789"]] | dfr into-df | dfr as-datetime "%Y-%m-%dT%H:%M:%S.%9f" |
-                polars with-column [ (polars col datetime | polars datepart year | polars as datetime_year ),
+                dfr with-column [ (dfr col datetime | dfr datepart year | dfr as datetime_year ),
-                (polars col datetime | polars datepart month | polars as datetime_month ),
+                (dfr col datetime | dfr datepart month | dfr as datetime_month ),
-                (polars col datetime | polars datepart day | polars as datetime_day ),
+                (dfr col datetime | dfr datepart day | dfr as datetime_day ),
-                (polars col datetime | polars datepart hour | polars as datetime_hour ),
+                (dfr col datetime | dfr datepart hour | dfr as datetime_hour ),
-                (polars col datetime | polars datepart minute | polars as datetime_minute ),
+                (dfr col datetime | dfr datepart minute | dfr as datetime_minute ),
-                (polars col datetime | polars datepart second | polars as datetime_second ),
+                (dfr col datetime | dfr datepart second | dfr as datetime_second ),
-                (polars col datetime | polars datepart nanosecond | polars as datetime_ns ) ]"#,
+                (dfr col datetime | dfr datepart nanosecond | dfr as datetime_ns ) ]"#,
                 result: Some(
-                    NuDataFrame::try_from_series_vec(
+                    NuDataFrame::try_from_series(
                         vec![
                             Series::new("datetime", &[dt.timestamp_nanos_opt()])
                                 .cast(&DataType::Datetime(TimeUnit::Nanoseconds, None))
@@ -119,16 +108,16 @@ impl PluginCommand for ExprDatePart {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let part: Spanned<String> = call.req(0)?;
+        let part: Spanned<String> = call.req(engine_state, stack, 0)?;
 
-        let expr = NuExpression::try_from_pipeline(plugin, input, call.head)?;
+        let expr = NuExpression::try_from_pipeline(input, call.head)?;
         let expr_dt = expr.into_polars().dt();
-        let expr: NuExpression  = match part.item.as_str() {
+        let expr = match part.item.as_str() {
             "year" => expr_dt.year(),
             "quarter" => expr_dt.quarter(),
             "month" => expr_dt.month(),
@@ -141,26 +130,41 @@ impl PluginCommand for ExprDatePart {
             "microsecond" => expr_dt.microsecond(),
             "nanosecond" => expr_dt.nanosecond(),
             _ => {
-                return Err(LabeledError::from(ShellError::UnsupportedInput {
+                return Err(ShellError::UnsupportedInput {
                     msg: format!("{} is not a valid datepart, expected one of year, month, day, hour, minute, second, millisecond, microsecond, nanosecond", part.item),
                     input: "value originates from here".to_string(),
                     msg_span: call.head,
                     input_span: part.span,
-                }))
+                });
             }
         }.into();
-        expr.to_pipeline_data(plugin, engine, call.head)
+
-            .map_err(LabeledError::from)
+        Ok(PipelineData::Value(
+            NuExpression::into_value(expr, call.head),
+            None,
+        ))
     }
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
+    use crate::dataframe::eager::ToNu;
+    use crate::dataframe::eager::WithColumn;
+    use crate::dataframe::expressions::ExprAlias;
+    use crate::dataframe::expressions::ExprCol;
+    use crate::dataframe::series::AsDateTime;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ExprDatePart)
+        test_dataframe(vec![
+            Box::new(ExprDatePart {}),
+            Box::new(ExprCol {}),
+            Box::new(ToNu {}),
+            Box::new(AsDateTime {}),
+            Box::new(WithColumn {}),
+            Box::new(ExprAlias {}),
+        ])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/expressions/expressions_macro.rs

@@ -2,12 +2,7 @@
 /// All of these expressions have an identical body and only require
 /// to have a change in the name, description and expression function
 use crate::dataframe::values::{Column, NuDataFrame, NuExpression, NuLazyFrame};
-use crate::values::CustomValueSupport;
+use nu_engine::command_prelude::*;
-use crate::PolarsPlugin;
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, Type, Value,
-};
 
 // The structs defined in this file are structs that form part of other commands
 // since they share a similar name
@@ -16,9 +11,7 @@ macro_rules! expr_command {
         #[derive(Clone)]
         pub struct $command;
 
-        impl PluginCommand for $command {
+        impl Command for $command {
-            type Plugin = PolarsPlugin;
-
             fn name(&self) -> &str {
                 $name
             }
@@ -29,7 +22,6 @@ macro_rules! expr_command {
 
             fn signature(&self) -> Signature {
                 Signature::build(self.name())
-                    .usage($desc)
                     .input_output_type(
                         Type::Custom("expression".into()),
                         Type::Custom("expression".into()),
@@ -43,27 +35,35 @@ macro_rules! expr_command {
 
             fn run(
                 &self,
-                plugin: &Self::Plugin,
+                _engine_state: &EngineState,
-                engine: &EngineInterface,
+                _stack: &mut Stack,
-                call: &EvaluatedCall,
+                call: &Call,
                 input: PipelineData,
-            ) -> Result<PipelineData, LabeledError> {
+            ) -> Result<PipelineData, ShellError> {
-                let expr = NuExpression::try_from_pipeline(plugin, input, call.head)
+                let expr = NuExpression::try_from_pipeline(input, call.head)?;
-                    .map_err(LabeledError::from)?;
                 let expr: NuExpression = expr.into_polars().$func().into();
-                expr.to_pipeline_data(plugin, engine, call.head)
+
-                    .map_err(LabeledError::from)
+                Ok(PipelineData::Value(
+                    NuExpression::into_value(expr, call.head),
+                    None,
+                ))
             }
         }
 
         #[cfg(test)]
         mod $test {
+            use super::super::super::test_dataframe::test_dataframe;
             use super::*;
-            use crate::test::test_polars_plugin_command;
+            use crate::dataframe::lazy::aggregate::LazyAggregate;
+            use crate::dataframe::lazy::groupby::ToLazyGroupBy;
 
             #[test]
-            fn test_examples() -> Result<(), ShellError> {
+            fn test_examples() {
-                test_polars_plugin_command(&$command)
+                test_dataframe(vec![
+                    Box::new($command {}),
+                    Box::new(LazyAggregate {}),
+                    Box::new(ToLazyGroupBy {}),
+                ])
             }
         }
     };
@@ -72,43 +72,59 @@ macro_rules! expr_command {
         #[derive(Clone)]
         pub struct $command;
 
-        impl PluginCommand for $command {
+        impl Command for $command {
-            type Plugin = PolarsPlugin;
+            fn name(&self) -> &str {
+                $name
+            }
+
+            fn usage(&self) -> &str {
+                $desc
+            }
 
             fn signature(&self) -> Signature {
                 Signature::build(self.name())
-                    .usage($desc)
                     .input_output_type(
                         Type::Custom("expression".into()),
                         Type::Custom("expression".into()),
                     )
                     .category(Category::Custom("expression".into()))
-                    .plugin_examples($examples)
+            }
+
+            fn examples(&self) -> Vec<Example> {
+                $examples
             }
 
             fn run(
                 &self,
-                _plugin: &Self::Plugin,
+                _engine_state: &EngineState,
-                engine: &EngineInterface,
+                _stack: &mut Stack,
-                call: &EvaluatedCall,
+                call: &Call,
                 input: PipelineData,
-            ) -> Result<PipelineData, LabeledError> {
+            ) -> Result<PipelineData, ShellError> {
-                let expr = NuExpression::try_from_pipeline(input, call.head)
+                let expr = NuExpression::try_from_pipeline(input, call.head)?;
-                    .map_err(LabeledError::from)?;
                 let expr: NuExpression = expr.into_polars().$func($ddof).into();
-                expr.to_pipeline_data(plugin, engine, call.head)
+
-                    .map_err(LabeledError::from)
+                Ok(PipelineData::Value(
+                    NuExpression::into_value(expr, call.head),
+                    None,
+                ))
             }
         }
 
         #[cfg(test)]
         mod $test {
+            use super::super::super::test_dataframe::test_dataframe;
             use super::*;
-            use crate::test::test_polars_plugin_command;
+            use crate::dataframe::lazy::aggregate::LazyAggregate;
+            use crate::dataframe::lazy::groupby::ToLazyGroupBy;
 
             #[test]
-            fn test_examples() -> Result<(), ShellError> {
+            fn test_examples() {
-                test_polars_plugin_command(&$command)
+                test_dataframe(vec![
+                    Box::new($command {}),
+                    Box::new(LazyAggregate {}),
+                    Box::new(ToLazyGroupBy {}),
+                ])
             }
         }
     };
@@ -121,9 +137,7 @@ macro_rules! lazy_expr_command {
         #[derive(Clone)]
         pub struct $command;
 
-        impl PluginCommand for $command {
+        impl Command for $command {
-            type Plugin = PolarsPlugin;
-
             fn name(&self) -> &str {
                 $name
             }
@@ -134,7 +148,6 @@ macro_rules! lazy_expr_command {
 
             fn signature(&self) -> Signature {
                 Signature::build(self.name())
-                    .usage($desc)
                     .input_output_types(vec![
                         (
                             Type::Custom("expression".into()),
@@ -154,18 +167,17 @@ macro_rules! lazy_expr_command {
 
             fn run(
                 &self,
-                plugin: &Self::Plugin,
+                _engine_state: &EngineState,
-                engine: &EngineInterface,
+                _stack: &mut Stack,
-                call: &EvaluatedCall,
+                call: &Call,
                 input: PipelineData,
-            ) -> Result<PipelineData, LabeledError> {
+            ) -> Result<PipelineData, ShellError> {
-                let value = input.into_value(call.head)?;
+                let value = input.into_value(call.head);
-                if NuDataFrame::can_downcast(&value) || NuLazyFrame::can_downcast(&value) {
+                if NuDataFrame::can_downcast(&value) {
-                    let lazy = NuLazyFrame::try_from_value_coerce(plugin, &value)
+                    let lazy = NuLazyFrame::try_from_value(value)?;
-                        .map_err(LabeledError::from)?;
                     let lazy = NuLazyFrame::new(
                         lazy.from_eager,
-                        lazy.to_polars()
+                        lazy.into_polars()
                             .$func()
                             .map_err(|e| ShellError::GenericError {
                                 error: "Dataframe Error".into(),
@@ -173,29 +185,49 @@ macro_rules! lazy_expr_command {
                                 help: None,
                                 span: None,
                                 inner: vec![],
-                            })
+                            })?,
-                            .map_err(LabeledError::from)?,
                     );
-                    lazy.to_pipeline_data(plugin, engine, call.head)
+
-                        .map_err(LabeledError::from)
+                    Ok(PipelineData::Value(lazy.into_value(call.head)?, None))
                 } else {
-                    let expr =
+                    let expr = NuExpression::try_from_value(value)?;
-                        NuExpression::try_from_value(plugin, &value).map_err(LabeledError::from)?;
                     let expr: NuExpression = expr.into_polars().$func().into();
-                    expr.to_pipeline_data(plugin, engine, call.head)
+
-                        .map_err(LabeledError::from)
+                    Ok(PipelineData::Value(
+                        NuExpression::into_value(expr, call.head),
+                        None,
+                    ))
                 }
             }
         }
 
         #[cfg(test)]
         mod $test {
+            use super::super::super::test_dataframe::{
+                build_test_engine_state, test_dataframe_example,
+            };
             use super::*;
-            use crate::test::test_polars_plugin_command;
+            use crate::dataframe::lazy::aggregate::LazyAggregate;
+            use crate::dataframe::lazy::groupby::ToLazyGroupBy;
 
             #[test]
-            fn test_examples() -> Result<(), ShellError> {
+            fn test_examples_dataframe() {
-                test_polars_plugin_command(&$command)
+                // the first example should be a for the dataframe case
+                let example = &$command.examples()[0];
+                let mut engine_state = build_test_engine_state(vec![Box::new($command {})]);
+                test_dataframe_example(&mut engine_state, &example)
+            }
+
+            #[test]
+            fn test_examples_expressions() {
+                // the second example should be a for the dataframe case
+                let example = &$command.examples()[1];
+                let mut engine_state = build_test_engine_state(vec![
+                    Box::new($command {}),
+                    Box::new(LazyAggregate {}),
+                    Box::new(ToLazyGroupBy {}),
+                ]);
+                test_dataframe_example(&mut engine_state, &example)
             }
         }
     };
@@ -204,9 +236,7 @@ macro_rules! lazy_expr_command {
         #[derive(Clone)]
         pub struct $command;
 
-        impl PluginCommand for $command {
+        impl Command for $command {
-            type Plugin = PolarsPlugin;
-
             fn name(&self) -> &str {
                 $name
             }
@@ -214,6 +244,7 @@ macro_rules! lazy_expr_command {
             fn usage(&self) -> &str {
                 $desc
             }
+
             fn signature(&self) -> Signature {
                 Signature::build(self.name())
                     .input_output_types(vec![
@@ -235,18 +266,17 @@ macro_rules! lazy_expr_command {
 
             fn run(
                 &self,
-                plugin: &Self::Plugin,
+                _engine_state: &EngineState,
-                engine: &EngineInterface,
+                _stack: &mut Stack,
-                call: &EvaluatedCall,
+                call: &Call,
                 input: PipelineData,
-            ) -> Result<PipelineData, LabeledError> {
+            ) -> Result<PipelineData, ShellError> {
-                let value = input.into_value(call.head)?;
+                let value = input.into_value(call.head);
-                if NuDataFrame::can_downcast(&value) || NuLazyFrame::can_downcast(&value) {
+                if NuDataFrame::can_downcast(&value) {
-                    let lazy = NuLazyFrame::try_from_value_coerce(plugin, &value)
+                    let lazy = NuLazyFrame::try_from_value(value)?;
-                        .map_err(LabeledError::from)?;
                     let lazy = NuLazyFrame::new(
                         lazy.from_eager,
-                        lazy.to_polars()
+                        lazy.into_polars()
                             .$func($ddof)
                             .map_err(|e| ShellError::GenericError {
                                 error: "Dataframe Error".into(),
@@ -254,28 +284,49 @@ macro_rules! lazy_expr_command {
                                 help: None,
                                 span: None,
                                 inner: vec![],
-                            })
+                            })?,
-                            .map_err(LabeledError::from)?,
                     );
-                    lazy.to_pipeline_data(plugin, engine, call.head)
+
-                        .map_err(LabeledError::from)
+                    Ok(PipelineData::Value(lazy.into_value(call.head)?, None))
                 } else {
-                    let expr = NuExpression::try_from_value(plugin, &value)?;
+                    let expr = NuExpression::try_from_value(value)?;
                     let expr: NuExpression = expr.into_polars().$func($ddof).into();
-                    expr.to_pipeline_data(plugin, engine, call.head)
+
-                        .map_err(LabeledError::from)
+                    Ok(PipelineData::Value(
+                        NuExpression::into_value(expr, call.head),
+                        None,
+                    ))
                 }
             }
         }
 
         #[cfg(test)]
         mod $test {
+            use super::super::super::test_dataframe::{
+                build_test_engine_state, test_dataframe_example,
+            };
             use super::*;
-            use crate::test::test_polars_plugin_command;
+            use crate::dataframe::lazy::aggregate::LazyAggregate;
+            use crate::dataframe::lazy::groupby::ToLazyGroupBy;
 
             #[test]
-            fn test_examples() -> Result<(), ShellError> {
+            fn test_examples_dataframe() {
-                test_polars_plugin_command(&$command)
+                // the first example should be a for the dataframe case
+                let example = &$command.examples()[0];
+                let mut engine_state = build_test_engine_state(vec![Box::new($command {})]);
+                test_dataframe_example(&mut engine_state, &example)
+            }
+
+            #[test]
+            fn test_examples_expressions() {
+                // the second example should be a for the dataframe case
+                let example = &$command.examples()[1];
+                let mut engine_state = build_test_engine_state(vec![
+                    Box::new($command {}),
+                    Box::new(LazyAggregate {}),
+                    Box::new(ToLazyGroupBy {}),
+                ]);
+                test_dataframe_example(&mut engine_state, &example)
             }
         }
     };
@@ -285,7 +336,7 @@ macro_rules! lazy_expr_command {
 // Expands to a command definition for a list expression
 expr_command!(
     ExprList,
-    "polars implode",
+    "dfr implode",
     "Aggregates a group to a Series.",
     vec![Example {
         description: "",
@@ -300,7 +351,7 @@ expr_command!(
 // Expands to a command definition for a agg groups expression
 expr_command!(
     ExprAggGroups,
-    "polars agg-groups",
+    "dfr agg-groups",
     "Creates an agg_groups expression.",
     vec![Example {
         description: "",
@@ -315,7 +366,7 @@ expr_command!(
 // Expands to a command definition for a count expression
 expr_command!(
     ExprCount,
-    "polars count",
+    "dfr count",
     "Creates a count expression.",
     vec![Example {
         description: "",
@@ -330,11 +381,11 @@ expr_command!(
 // Expands to a command definition for a not expression
 expr_command!(
     ExprNot,
-    "polars expr-not",
+    "dfr expr-not",
     "Creates a not expression.",
     vec![Example {
         description: "Creates a not expression",
-        example: "(polars col a) > 2) | polars expr-not",
+        example: "(dfr col a) > 2) | dfr expr-not",
         result: None,
     },],
     not,
@@ -345,12 +396,12 @@ expr_command!(
 // Expands to a command definition for max aggregation
 lazy_expr_command!(
     ExprMax,
-    "polars max",
+    "dfr max",
     "Creates a max expression or aggregates columns to their max value.",
     vec![
         Example {
             description: "Max value from columns in a dataframe",
-            example: "[[a b]; [6 2] [1 4] [4 1]] | polars into-df | polars max",
+            example: "[[a b]; [6 2] [1 4] [4 1]] | dfr into-df | dfr max",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -366,9 +417,9 @@ lazy_expr_command!(
         Example {
             description: "Max aggregation for a group-by",
             example: r#"[[a b]; [one 2] [one 4] [two 1]]
-    | polars into-df
+    | dfr into-df
-    | polars group-by a
+    | dfr group-by a
-    | polars agg (polars col b | polars max)"#,
+    | dfr agg (dfr col b | dfr max)"#,
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -396,12 +447,12 @@ lazy_expr_command!(
 // Expands to a command definition for min aggregation
 lazy_expr_command!(
     ExprMin,
-    "polars min",
+    "dfr min",
     "Creates a min expression or aggregates columns to their min value.",
     vec![
         Example {
             description: "Min value from columns in a dataframe",
-            example: "[[a b]; [6 2] [1 4] [4 1]] | polars into-df | polars min",
+            example: "[[a b]; [6 2] [1 4] [4 1]] | dfr into-df | dfr min",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -417,9 +468,9 @@ lazy_expr_command!(
         Example {
             description: "Min aggregation for a group-by",
             example: r#"[[a b]; [one 2] [one 4] [two 1]]
-    | polars into-df
+    | dfr into-df
-    | polars group-by a
+    | dfr group-by a
-    | polars agg (polars col b | polars min)"#,
+    | dfr agg (dfr col b | dfr min)"#,
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -447,12 +498,12 @@ lazy_expr_command!(
 // Expands to a command definition for sum aggregation
 lazy_expr_command!(
     ExprSum,
-    "polars sum",
+    "dfr sum",
     "Creates a sum expression for an aggregation or aggregates columns to their sum value.",
     vec![
         Example {
             description: "Sums all columns in a dataframe",
-            example: "[[a b]; [6 2] [1 4] [4 1]] | polars into-df | polars sum",
+            example: "[[a b]; [6 2] [1 4] [4 1]] | dfr into-df | dfr sum",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -468,9 +519,9 @@ lazy_expr_command!(
         Example {
             description: "Sum aggregation for a group-by",
             example: r#"[[a b]; [one 2] [one 4] [two 1]]
-    | polars into-df
+    | dfr into-df
-    | polars group-by a
+    | dfr group-by a
-    | polars agg (polars col b | polars sum)"#,
+    | dfr agg (dfr col b | dfr sum)"#,
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -498,12 +549,12 @@ lazy_expr_command!(
 // Expands to a command definition for mean aggregation
 lazy_expr_command!(
     ExprMean,
-    "polars mean",
+    "dfr mean",
     "Creates a mean expression for an aggregation or aggregates columns to their mean value.",
     vec![
         Example {
             description: "Mean value from columns in a dataframe",
-            example: "[[a b]; [6 2] [4 2] [2 2]] | polars into-df | polars mean",
+            example: "[[a b]; [6 2] [4 2] [2 2]] | dfr into-df | dfr mean",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -519,9 +570,9 @@ lazy_expr_command!(
         Example {
             description: "Mean aggregation for a group-by",
             example: r#"[[a b]; [one 2] [one 4] [two 1]]
-    | polars into-df
+    | dfr into-df
-    | polars group-by a
+    | dfr group-by a
-    | polars agg (polars col b | polars mean)"#,
+    | dfr agg (dfr col b | dfr mean)"#,
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -545,16 +596,50 @@ lazy_expr_command!(
     test_mean
 );
 
+// ExprMedian command
+// Expands to a command definition for median aggregation
+expr_command!(
+    ExprMedian,
+    "dfr median",
+    "Creates a median expression for an aggregation.",
+    vec![Example {
+        description: "Median aggregation for a group-by",
+        example: r#"[[a b]; [one 2] [one 4] [two 1]]
+    | dfr into-df
+    | dfr group-by a
+    | dfr agg (dfr col b | dfr median)"#,
+        result: Some(
+            NuDataFrame::try_from_columns(
+                vec![
+                    Column::new(
+                        "a".to_string(),
+                        vec![Value::test_string("one"), Value::test_string("two")],
+                    ),
+                    Column::new(
+                        "b".to_string(),
+                        vec![Value::test_float(3.0), Value::test_float(1.0)],
+                    ),
+                ],
+                None
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Span::test_data()),
+        ),
+    },],
+    median,
+    test_median
+);
+
 // ExprStd command
 // Expands to a command definition for std aggregation
 lazy_expr_command!(
     ExprStd,
-    "polars std",
+    "dfr std",
     "Creates a std expression for an aggregation of std value from columns in a dataframe.",
     vec![
         Example {
             description: "Std value from columns in a dataframe",
-            example: "[[a b]; [6 2] [4 2] [2 2]] | polars into-df | polars std",
+            example: "[[a b]; [6 2] [4 2] [2 2]] | dfr into-df | dfr std",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -570,9 +655,9 @@ lazy_expr_command!(
         Example {
             description: "Std aggregation for a group-by",
             example: r#"[[a b]; [one 2] [one 2] [two 1] [two 1]]
-    | polars into-df
+    | dfr into-df
-    | polars group-by a
+    | dfr group-by a
-    | polars agg (polars col b | polars std)"#,
+    | dfr agg (dfr col b | dfr std)"#,
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -601,13 +686,13 @@ lazy_expr_command!(
 // Expands to a command definition for var aggregation
 lazy_expr_command!(
     ExprVar,
-    "polars var",
+    "dfr var",
     "Create a var expression for an aggregation.",
     vec![
         Example {
             description:
                 "Var value from columns in a dataframe or aggregates columns to their var value",
-            example: "[[a b]; [6 2] [4 2] [2 2]] | polars into-df | polars var",
+            example: "[[a b]; [6 2] [4 2] [2 2]] | dfr into-df | dfr var",
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![
@@ -623,9 +708,9 @@ lazy_expr_command!(
         Example {
             description: "Var aggregation for a group-by",
             example: r#"[[a b]; [one 2] [one 2] [two 1] [two 1]]
-    | polars into-df
+    | dfr into-df
-    | polars group-by a
+    | dfr group-by a
-    | polars agg (polars col b | polars var)"#,
+    | dfr agg (dfr col b | dfr var)"#,
             result: Some(
                 NuDataFrame::try_from_columns(
                     vec![

crates/nu-cmd-dataframe/src/dataframe/expressions/is_in.rs

@@ -0,0 +1,116 @@
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression};
+use nu_engine::command_prelude::*;
+
+use polars::prelude::{lit, DataType};
+
+#[derive(Clone)]
+pub struct ExprIsIn;
+
+impl Command for ExprIsIn {
+    fn name(&self) -> &str {
+        "dfr is-in"
+    }
+
+    fn usage(&self) -> &str {
+        "Creates an is-in expression."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .required(
+                "list",
+                SyntaxShape::List(Box::new(SyntaxShape::Any)),
+                "List to check if values are in",
+            )
+            .input_output_type(
+                Type::Custom("expression".into()),
+                Type::Custom("expression".into()),
+            )
+            .category(Category::Custom("expression".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Creates a is-in expression",
+            example: r#"let df = ([[a b]; [one 1] [two 2] [three 3]] | dfr into-df);
+    $df | dfr with-column (dfr col a | dfr is-in [one two] | dfr as a_in)"#,
+            result: Some(
+                NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a".to_string(),
+                            vec![
+                                Value::test_string("one"),
+                                Value::test_string("two"),
+                                Value::test_string("three"),
+                            ],
+                        ),
+                        Column::new(
+                            "b".to_string(),
+                            vec![Value::test_int(1), Value::test_int(2), Value::test_int(3)],
+                        ),
+                        Column::new(
+                            "a_in".to_string(),
+                            vec![
+                                Value::test_bool(true),
+                                Value::test_bool(true),
+                                Value::test_bool(false),
+                            ],
+                        ),
+                    ],
+                    None,
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Span::test_data()),
+            ),
+        }]
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["check", "contained", "is-contain", "match"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let list: Vec<Value> = call.req(engine_state, stack, 0)?;
+        let expr = NuExpression::try_from_pipeline(input, call.head)?;
+
+        let values =
+            NuDataFrame::try_from_columns(vec![Column::new("list".to_string(), list)], None)?;
+        let list = values.as_series(call.head)?;
+
+        if matches!(list.dtype(), DataType::Object(..)) {
+            return Err(ShellError::IncompatibleParametersSingle {
+                msg: "Cannot use a mixed list as argument".into(),
+                span: call.head,
+            });
+        }
+
+        let expr: NuExpression = expr.into_polars().is_in(lit(list)).into();
+        Ok(PipelineData::Value(expr.into_value(call.head), None))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::super::super::test_dataframe::test_dataframe;
+    use super::*;
+    use crate::dataframe::eager::WithColumn;
+    use crate::dataframe::expressions::alias::ExprAlias;
+    use crate::dataframe::expressions::col::ExprCol;
+
+    #[test]
+    fn test_examples() {
+        test_dataframe(vec![
+            Box::new(ExprIsIn {}),
+            Box::new(ExprAlias {}),
+            Box::new(ExprCol {}),
+            Box::new(WithColumn {}),
+        ])
+    }
+}

crates/nu-cmd-dataframe/src/dataframe/expressions/lit.rs

@@ -1,17 +1,12 @@
-use crate::{dataframe::values::NuExpression, values::CustomValueSupport, PolarsPlugin};
+use crate::dataframe::values::NuExpression;
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
+use nu_engine::command_prelude::*;
-use nu_protocol::{
-    record, Category, Example, LabeledError, PipelineData, Signature, SyntaxShape, Type, Value,
-};
 
 #[derive(Clone)]
 pub struct ExprLit;
 
-impl PluginCommand for ExprLit {
+impl Command for ExprLit {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars lit"
+        "dfr lit"
     }
 
     fn usage(&self) -> &str {
@@ -32,7 +27,7 @@ impl PluginCommand for ExprLit {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Created a literal expression and converts it to a nu object",
-            example: "polars lit 2 | polars into-nu",
+            example: "dfr lit 2 | dfr into-nu",
             result: Some(Value::test_record(record! {
                 "expr" =>  Value::test_string("literal"),
                 "value" => Value::test_string("2"),
@@ -46,25 +41,29 @@ impl PluginCommand for ExprLit {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         _input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let literal: Value = call.req(0)?;
+        let literal: Value = call.req(engine_state, stack, 0)?;
-        let expr = NuExpression::try_from_value(plugin, &literal)?;
+
-        expr.to_pipeline_data(plugin, engine, call.head)
+        let expr = NuExpression::try_from_value(literal)?;
-            .map_err(LabeledError::from)
+        Ok(PipelineData::Value(
+            NuExpression::into_value(expr, call.head),
+            None,
+        ))
     }
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
+    use crate::dataframe::eager::ToNu;
 
     #[test]
-    fn test_examples() -> Result<(), nu_protocol::ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ExprLit)
+        test_dataframe(vec![Box::new(ExprLit {}), Box::new(ToNu {})])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/expressions/mod.rs

@@ -0,0 +1,62 @@
+mod alias;
+mod arg_where;
+mod col;
+mod concat_str;
+mod datepart;
+mod expressions_macro;
+mod is_in;
+mod lit;
+mod otherwise;
+mod quantile;
+mod when;
+
+use nu_protocol::engine::StateWorkingSet;
+
+pub(crate) use crate::dataframe::expressions::alias::ExprAlias;
+use crate::dataframe::expressions::arg_where::ExprArgWhere;
+pub(super) use crate::dataframe::expressions::col::ExprCol;
+pub(super) use crate::dataframe::expressions::concat_str::ExprConcatStr;
+pub(crate) use crate::dataframe::expressions::datepart::ExprDatePart;
+pub(crate) use crate::dataframe::expressions::expressions_macro::*;
+pub(super) use crate::dataframe::expressions::is_in::ExprIsIn;
+pub(super) use crate::dataframe::expressions::lit::ExprLit;
+pub(super) use crate::dataframe::expressions::otherwise::ExprOtherwise;
+pub(super) use crate::dataframe::expressions::quantile::ExprQuantile;
+pub(super) use crate::dataframe::expressions::when::ExprWhen;
+
+pub fn add_expressions(working_set: &mut StateWorkingSet) {
+    macro_rules! bind_command {
+            ( $command:expr ) => {
+                working_set.add_decl(Box::new($command));
+            };
+            ( $( $command:expr ),* ) => {
+                $( working_set.add_decl(Box::new($command)); )*
+            };
+        }
+
+    // Dataframe commands
+    bind_command!(
+        ExprAlias,
+        ExprArgWhere,
+        ExprCol,
+        ExprConcatStr,
+        ExprCount,
+        ExprLit,
+        ExprWhen,
+        ExprOtherwise,
+        ExprQuantile,
+        ExprList,
+        ExprAggGroups,
+        ExprCount,
+        ExprIsIn,
+        ExprNot,
+        ExprMax,
+        ExprMin,
+        ExprSum,
+        ExprMean,
+        ExprMedian,
+        ExprStd,
+        ExprVar,
+        ExprDatePart
+    );
+}

crates/nu-cmd-dataframe/src/dataframe/expressions/otherwise.rs

@@ -1,20 +1,12 @@
-use crate::{
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression, NuWhen};
-    dataframe::values::{Column, NuDataFrame, NuExpression, NuWhen, NuWhenType},
+use nu_engine::command_prelude::*;
-    values::CustomValueSupport,
-    PolarsPlugin,
-};
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, Signature, Span, SyntaxShape, Type, Value,
-};
 
 #[derive(Clone)]
 pub struct ExprOtherwise;
 
-impl PluginCommand for ExprOtherwise {
+impl Command for ExprOtherwise {
-    type Plugin = PolarsPlugin;
     fn name(&self) -> &str {
-        "polars otherwise"
+        "dfr otherwise"
     }
 
     fn usage(&self) -> &str {
@@ -36,26 +28,26 @@ impl PluginCommand for ExprOtherwise {
         vec![
             Example {
                 description: "Create a when conditions",
-                example: "polars when ((polars col a) > 2) 4 | polars otherwise 5",
+                example: "dfr when ((dfr col a) > 2) 4 | dfr otherwise 5",
                 result: None,
             },
             Example {
                 description: "Create a when conditions",
                 example:
-                    "polars when ((polars col a) > 2) 4 | polars when ((polars col a) < 0) 6 | polars otherwise 0",
+                    "dfr when ((dfr col a) > 2) 4 | dfr when ((dfr col a) < 0) 6 | dfr otherwise 0",
                 result: None,
             },
             Example {
                 description: "Create a new column for the dataframe",
                 example: r#"[[a b]; [6 2] [1 4] [4 1]]
-   | polars into-lazy
+   | dfr into-lazy
-   | polars with-column (
+   | dfr with-column (
-    polars when ((polars col a) > 2) 4 | polars otherwise 5 | polars as c
+    dfr when ((dfr col a) > 2) 4 | dfr otherwise 5 | dfr as c
      )
-   | polars with-column (
+   | dfr with-column (
-    polars when ((polars col a) > 5) 10 | polars when ((polars col a) < 2) 6 | polars otherwise 0 | polars as d
+    dfr when ((dfr col a) > 5) 10 | dfr when ((dfr col a) < 2) 6 | dfr otherwise 0 | dfr as d
      )
-   | polars collect"#,
+   | dfr collect"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -91,34 +83,44 @@ impl PluginCommand for ExprOtherwise {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let otherwise_predicate: Value = call.req(0)?;
+        let otherwise_predicate: Value = call.req(engine_state, stack, 0)?;
-        let otherwise_predicate = NuExpression::try_from_value(plugin, &otherwise_predicate)?;
+        let otherwise_predicate = NuExpression::try_from_value(otherwise_predicate)?;
 
-        let value = input.into_value(call.head)?;
+        let value = input.into_value(call.head);
-        let complete: NuExpression = match NuWhen::try_from_value(plugin, &value)?.when_type {
+        let complete: NuExpression = match NuWhen::try_from_value(value)? {
-            NuWhenType::Then(then) => then.otherwise(otherwise_predicate.into_polars()).into(),
+            NuWhen::Then(then) => then.otherwise(otherwise_predicate.into_polars()).into(),
-            NuWhenType::ChainedThen(chained_when) => chained_when
+            NuWhen::ChainedThen(chained_when) => chained_when
                 .otherwise(otherwise_predicate.into_polars())
                 .into(),
         };
-        complete
+
-            .to_pipeline_data(plugin, engine, call.head)
+        Ok(PipelineData::Value(complete.into_value(call.head), None))
-            .map_err(LabeledError::from)
     }
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
+    use crate::dataframe::eager::{ToNu, WithColumn};
+    use crate::dataframe::expressions::when::ExprWhen;
+    use crate::dataframe::expressions::{ExprAlias, ExprCol};
+
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), nu_protocol::ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ExprOtherwise)
+        test_dataframe(vec![
+            Box::new(WithColumn {}),
+            Box::new(ExprCol {}),
+            Box::new(ExprAlias {}),
+            Box::new(ExprWhen {}),
+            Box::new(ExprOtherwise {}),
+            Box::new(ToNu {}),
+        ])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/expressions/quantile.rs

@@ -0,0 +1,101 @@
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression};
+use nu_engine::command_prelude::*;
+
+use polars::prelude::{lit, QuantileInterpolOptions};
+
+#[derive(Clone)]
+pub struct ExprQuantile;
+
+impl Command for ExprQuantile {
+    fn name(&self) -> &str {
+        "dfr quantile"
+    }
+
+    fn usage(&self) -> &str {
+        "Aggregates the columns to the selected quantile."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .required(
+                "quantile",
+                SyntaxShape::Number,
+                "quantile value for quantile operation",
+            )
+            .input_output_type(
+                Type::Custom("expression".into()),
+                Type::Custom("expression".into()),
+            )
+            .category(Category::Custom("expression".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Quantile aggregation for a group-by",
+            example: r#"[[a b]; [one 2] [one 4] [two 1]]
+    | dfr into-df
+    | dfr group-by a
+    | dfr agg (dfr col b | dfr quantile 0.5)"#,
+            result: Some(
+                NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a".to_string(),
+                            vec![Value::test_string("one"), Value::test_string("two")],
+                        ),
+                        Column::new(
+                            "b".to_string(),
+                            vec![Value::test_float(4.0), Value::test_float(1.0)],
+                        ),
+                    ],
+                    None,
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Span::test_data()),
+            ),
+        }]
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["statistics", "percentile", "distribution"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let value = input.into_value(call.head);
+        let quantile: f64 = call.req(engine_state, stack, 0)?;
+
+        let expr = NuExpression::try_from_value(value)?;
+        let expr: NuExpression = expr
+            .into_polars()
+            .quantile(lit(quantile), QuantileInterpolOptions::default())
+            .into();
+
+        Ok(PipelineData::Value(
+            NuExpression::into_value(expr, call.head),
+            None,
+        ))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::super::super::test_dataframe::test_dataframe;
+    use super::*;
+    use crate::dataframe::lazy::aggregate::LazyAggregate;
+    use crate::dataframe::lazy::groupby::ToLazyGroupBy;
+
+    #[test]
+    fn test_examples() {
+        test_dataframe(vec![
+            Box::new(ExprQuantile {}),
+            Box::new(LazyAggregate {}),
+            Box::new(ToLazyGroupBy {}),
+        ])
+    }
+}

crates/nu-cmd-dataframe/src/dataframe/expressions/when.rs

@@ -1,22 +1,14 @@
-use crate::{
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression, NuWhen};
-    dataframe::values::{Column, NuDataFrame, NuExpression, NuWhen},
+use nu_engine::command_prelude::*;
-    values::{CustomValueSupport, NuWhenType},
+
-    PolarsPlugin,
-};
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, Signature, Span, SyntaxShape, Type, Value,
-};
 use polars::prelude::when;
 
 #[derive(Clone)]
 pub struct ExprWhen;
 
-impl PluginCommand for ExprWhen {
+impl Command for ExprWhen {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars when"
+        "dfr when"
     }
 
     fn usage(&self) -> &str {
@@ -46,25 +38,25 @@ impl PluginCommand for ExprWhen {
         vec![
             Example {
                 description: "Create a when conditions",
-                example: "polars when ((polars col a) > 2) 4",
+                example: "dfr when ((dfr col a) > 2) 4",
                 result: None,
             },
             Example {
                 description: "Create a when conditions",
-                example: "polars when ((polars col a) > 2) 4 | polars when ((polars col a) < 0) 6",
+                example: "dfr when ((dfr col a) > 2) 4 | dfr when ((dfr col a) < 0) 6",
                 result: None,
             },
             Example {
                 description: "Create a new column for the dataframe",
                 example: r#"[[a b]; [6 2] [1 4] [4 1]]
-   | polars into-lazy
+   | dfr into-lazy
-   | polars with-column (
+   | dfr with-column (
-    polars when ((polars col a) > 2) 4 | polars otherwise 5 | polars as c
+    dfr when ((dfr col a) > 2) 4 | dfr otherwise 5 | dfr as c
      )
-   | polars with-column (
+   | dfr with-column (
-    polars when ((polars col a) > 5) 10 | polars when ((polars col a) < 2) 6 | polars otherwise 0 | polars as d
+    dfr when ((dfr col a) > 5) 10 | dfr when ((dfr col a) < 2) 6 | dfr otherwise 0 | dfr as d
      )
-   | polars collect"#,
+   | dfr collect"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -100,47 +92,56 @@ impl PluginCommand for ExprWhen {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let when_predicate: Value = call.req(0)?;
+        let when_predicate: Value = call.req(engine_state, stack, 0)?;
-        let when_predicate = NuExpression::try_from_value(plugin, &when_predicate)?;
+        let when_predicate = NuExpression::try_from_value(when_predicate)?;
 
-        let then_predicate: Value = call.req(1)?;
+        let then_predicate: Value = call.req(engine_state, stack, 1)?;
-        let then_predicate = NuExpression::try_from_value(plugin, &then_predicate)?;
+        let then_predicate = NuExpression::try_from_value(then_predicate)?;
 
-        let value = input.into_value(call.head)?;
+        let value = input.into_value(call.head);
         let when_then: NuWhen = match value {
             Value::Nothing { .. } => when(when_predicate.into_polars())
                 .then(then_predicate.into_polars())
                 .into(),
-            v => match NuWhen::try_from_value(plugin, &v)?.when_type {
+            v => match NuWhen::try_from_value(v)? {
-                NuWhenType::Then(when_then) => when_then
+                NuWhen::Then(when_then) => when_then
                     .when(when_predicate.into_polars())
                     .then(then_predicate.into_polars())
                     .into(),
-                NuWhenType::ChainedThen(when_then_then) => when_then_then
+                NuWhen::ChainedThen(when_then_then) => when_then_then
                     .when(when_predicate.into_polars())
                     .then(then_predicate.into_polars())
                     .into(),
             },
         };
 
-        when_then
+        Ok(PipelineData::Value(when_then.into_value(call.head), None))
-            .to_pipeline_data(plugin, engine, call.head)
-            .map_err(LabeledError::from)
     }
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
+    use crate::dataframe::eager::{ToNu, WithColumn};
+    use crate::dataframe::expressions::otherwise::ExprOtherwise;
+    use crate::dataframe::expressions::{ExprAlias, ExprCol};
+
     use super::*;
-    use crate::test::test_polars_plugin_command;
 
     #[test]
-    fn test_examples() -> Result<(), nu_protocol::ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&ExprWhen)
+        test_dataframe(vec![
+            Box::new(WithColumn {}),
+            Box::new(ExprCol {}),
+            Box::new(ExprAlias {}),
+            Box::new(ExprWhen {}),
+            Box::new(ExprOtherwise {}),
+            Box::new(ToNu {}),
+        ])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/lazy/aggregate.rs

@@ -1,24 +1,14 @@
-use crate::{
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression, NuLazyFrame, NuLazyGroupBy};
-    dataframe::values::{NuExpression, NuLazyFrame, NuLazyGroupBy},
+use nu_engine::command_prelude::*;
-    values::{Column, CustomValueSupport, NuDataFrame},
-    PolarsPlugin,
-};
 
-use nu_plugin::{EngineInterface, EvaluatedCall, PluginCommand};
-use nu_protocol::{
-    Category, Example, LabeledError, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
-    Value,
-};
 use polars::{datatypes::DataType, prelude::Expr};
 
 #[derive(Clone)]
 pub struct LazyAggregate;
 
-impl PluginCommand for LazyAggregate {
+impl Command for LazyAggregate {
-    type Plugin = PolarsPlugin;
-
     fn name(&self) -> &str {
-        "polars agg"
+        "dfr agg"
     }
 
     fn usage(&self) -> &str {
@@ -44,12 +34,12 @@ impl PluginCommand for LazyAggregate {
             Example {
                 description: "Group by and perform an aggregation",
                 example: r#"[[a b]; [1 2] [1 4] [2 6] [2 4]]
-    | polars into-df
+    | dfr into-df
-    | polars group-by a
+    | dfr group-by a
-    | polars agg [
+    | dfr agg [
-        (polars col b | polars min | polars as "b_min")
+        (dfr col b | dfr min | dfr as "b_min")
-        (polars col b | polars max | polars as "b_max")
+        (dfr col b | dfr max | dfr as "b_max")
-        (polars col b | polars sum | polars as "b_sum")
+        (dfr col b | dfr sum | dfr as "b_sum")
      ]"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
@@ -80,14 +70,14 @@ impl PluginCommand for LazyAggregate {
             Example {
                 description: "Group by and perform an aggregation",
                 example: r#"[[a b]; [1 2] [1 4] [2 6] [2 4]]
-    | polars into-lazy
+    | dfr into-lazy
-    | polars group-by a
+    | dfr group-by a
-    | polars agg [
+    | dfr agg [
-        (polars col b | polars min | polars as "b_min")
+        (dfr col b | dfr min | dfr as "b_min")
-        (polars col b | polars max | polars as "b_max")
+        (dfr col b | dfr max | dfr as "b_max")
-        (polars col b | polars sum | polars as "b_sum")
+        (dfr col b | dfr sum | dfr as "b_sum")
      ]
-    | polars collect"#,
+    | dfr collect"#,
                 result: Some(
                     NuDataFrame::try_from_columns(
                         vec![
@@ -119,37 +109,43 @@ impl PluginCommand for LazyAggregate {
 
     fn run(
         &self,
-        plugin: &Self::Plugin,
+        engine_state: &EngineState,
-        engine: &EngineInterface,
+        stack: &mut Stack,
-        call: &EvaluatedCall,
+        call: &Call,
         input: PipelineData,
-    ) -> Result<PipelineData, LabeledError> {
+    ) -> Result<PipelineData, ShellError> {
-        let vals: Vec<Value> = call.rest(0)?;
+        let vals: Vec<Value> = call.rest(engine_state, stack, 0)?;
         let value = Value::list(vals, call.head);
-        let expressions = NuExpression::extract_exprs(plugin, value)?;
+        let expressions = NuExpression::extract_exprs(value)?;
 
-        let group_by = NuLazyGroupBy::try_from_pipeline(plugin, input, call.head)?;
+        let group_by = NuLazyGroupBy::try_from_pipeline(input, call.head)?;
 
-        for expr in expressions.iter() {
+        if let Some(schema) = &group_by.schema {
-            if let Some(name) = get_col_name(expr) {
+            for expr in expressions.iter() {
-                let dtype = group_by.schema.schema.get(name.as_str());
+                if let Some(name) = get_col_name(expr) {
+                    let dtype = schema.get(name.as_str());
 
-                if matches!(dtype, Some(DataType::Object(..))) {
+                    if matches!(dtype, Some(DataType::Object(..))) {
-                    return Err(ShellError::GenericError {
+                        return Err(ShellError::GenericError {
                             error: "Object type column not supported for aggregation".into(),
                             msg: format!("Column '{name}' is type Object"),
                             span: Some(call.head),
                             help: Some("Aggregations cannot be performed on Object type columns. Use dtype command to check column types".into()),
                             inner: vec![],
-                        }).map_err(|e| e.into());
+                        });
+                    }
                 }
             }
         }
 
-        let polars = group_by.to_polars();
+        let lazy = NuLazyFrame {
-        let lazy = NuLazyFrame::new(false, polars.agg(&expressions));
+            from_eager: group_by.from_eager,
-        lazy.to_pipeline_data(plugin, engine, call.head)
+            lazy: Some(group_by.into_polars().agg(&expressions)),
-            .map_err(LabeledError::from)
+            schema: None,
+        };
+
+        let res = lazy.into_value(call.head)?;
+        Ok(PipelineData::Value(res, None))
     }
 }
 
@@ -201,11 +197,20 @@ fn get_col_name(expr: &Expr) -> Option<String> {
 
 #[cfg(test)]
 mod test {
+    use super::super::super::test_dataframe::test_dataframe;
     use super::*;
-    use crate::test::test_polars_plugin_command;
+    use crate::dataframe::expressions::{ExprAlias, ExprMax, ExprMin, ExprSum};
+    use crate::dataframe::lazy::groupby::ToLazyGroupBy;
 
     #[test]
-    fn test_examples() -> Result<(), ShellError> {
+    fn test_examples() {
-        test_polars_plugin_command(&LazyAggregate)
+        test_dataframe(vec![
+            Box::new(LazyAggregate {}),
+            Box::new(ToLazyGroupBy {}),
+            Box::new(ExprAlias {}),
+            Box::new(ExprMin {}),
+            Box::new(ExprMax {}),
+            Box::new(ExprSum {}),
+        ])
     }
 }

crates/nu-cmd-dataframe/src/dataframe/lazy/collect.rs

@@ -0,0 +1,73 @@
+use crate::dataframe::values::{Column, NuDataFrame, NuLazyFrame};
+use nu_engine::command_prelude::*;
+
+#[derive(Clone)]
+pub struct LazyCollect;
+
+impl Command for LazyCollect {
+    fn name(&self) -> &str {
+        "dfr collect"
+    }
+
+    fn usage(&self) -> &str {
+        "Collect lazy dataframe into eager dataframe."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
+            .category(Category::Custom("lazyframe".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "drop duplicates",
+            example: "[[a b]; [1 2] [3 4]] | dfr into-lazy | dfr collect",
+            result: Some(
+                NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a".to_string(),
+                            vec![Value::test_int(1), Value::test_int(3)],
+                        ),
+                        Column::new(
+                            "b".to_string(),
+                            vec![Value::test_int(2), Value::test_int(4)],
+                        ),
+                    ],
+                    None,
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Span::test_data()),
+            ),
+        }]
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let lazy = NuLazyFrame::try_from_pipeline(input, call.head)?;
+        let eager = lazy.collect(call.head)?;
+        let value = Value::custom(Box::new(eager), call.head);
+
+        Ok(PipelineData::Value(value, None))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::super::super::test_dataframe::test_dataframe;
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        test_dataframe(vec![Box::new(LazyCollect {})])
+    }
+}

crates/nu-cmd-dataframe/src/dataframe/lazy/explode.rs

@@ -0,0 +1,153 @@
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression, NuLazyFrame};
+use nu_engine::command_prelude::*;
+
+#[derive(Clone)]
+pub struct LazyExplode;
+
+impl Command for LazyExplode {
+    fn name(&self) -> &str {
+        "dfr explode"
+    }
+
+    fn usage(&self) -> &str {
+        "Explodes a dataframe or creates a explode expression."
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .rest(
+                "columns",
+                SyntaxShape::String,
+                "columns to explode, only applicable for dataframes",
+            )
+            .input_output_types(vec![
+                (
+                    Type::Custom("expression".into()),
+                    Type::Custom("expression".into()),
+                ),
+                (
+                    Type::Custom("dataframe".into()),
+                    Type::Custom("dataframe".into()),
+                ),
+            ])
+            .category(Category::Custom("lazyframe".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Explode the specified dataframe",
+                example: "[[id name hobbies]; [1 Mercy [Cycling Knitting]] [2 Bob [Skiing Football]]] | dfr into-df | dfr explode hobbies | dfr collect",
+                result: Some(
+                   NuDataFrame::try_from_columns(vec![
+                    Column::new(
+                        "id".to_string(),
+                        vec![
+                            Value::test_int(1),
+                            Value::test_int(1),
+                            Value::test_int(2),
+                            Value::test_int(2),
+                        ]),
+                    Column::new(
+                        "name".to_string(),
+                        vec![
+                            Value::test_string("Mercy"),
+                            Value::test_string("Mercy"),
+                            Value::test_string("Bob"),
+                            Value::test_string("Bob"),
+                        ]),
+                    Column::new(
+                        "hobbies".to_string(),
+                        vec![
+                            Value::test_string("Cycling"),
+                            Value::test_string("Knitting"),
+                            Value::test_string("Skiing"),
+                            Value::test_string("Football"),
+                        ]),
+                   ], None).expect("simple df for test should not fail")
+                   .into_value(Span::test_data()),
+                    )
+            },
+            Example {
+                description: "Select a column and explode the values",
+                example: "[[id name hobbies]; [1 Mercy [Cycling Knitting]] [2 Bob [Skiing Football]]] | dfr into-df | dfr select (dfr col hobbies | dfr explode)",
+                result: Some(
+                   NuDataFrame::try_from_columns(vec![
+                    Column::new(
+                        "hobbies".to_string(),
+                        vec![
+                            Value::test_string("Cycling"),
+                            Value::test_string("Knitting"),
+                            Value::test_string("Skiing"),
+                            Value::test_string("Football"),
+                        ]),
+                   ], None).expect("simple df for test should not fail")
+                   .into_value(Span::test_data()),
+                    ),
+            },
+        ]
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        explode(call, input)
+    }
+}
+
+pub(crate) fn explode(call: &Call, input: PipelineData) -> Result<PipelineData, ShellError> {
+    let value = input.into_value(call.head);
+    if NuDataFrame::can_downcast(&value) {
+        let df = NuLazyFrame::try_from_value(value)?;
+        let columns: Vec<String> = call
+            .positional_iter()
+            .filter_map(|e| e.as_string())
+            .collect();
+
+        let exploded = df
+            .into_polars()
+            .explode(columns.iter().map(AsRef::as_ref).collect::<Vec<&str>>());
+
+        Ok(PipelineData::Value(
+            NuLazyFrame::from(exploded).into_value(call.head)?,
+            None,
+        ))
+    } else {
+        let expr = NuExpression::try_from_value(value)?;
+        let expr: NuExpression = expr.into_polars().explode().into();
+
+        Ok(PipelineData::Value(
+            NuExpression::into_value(expr, call.head),
+            None,
+        ))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::super::super::test_dataframe::{build_test_engine_state, test_dataframe_example};
+    use super::*;
+    use crate::dataframe::lazy::aggregate::LazyAggregate;
+    use crate::dataframe::lazy::groupby::ToLazyGroupBy;
+
+    #[test]
+    fn test_examples_dataframe() {
+        let mut engine_state = build_test_engine_state(vec![Box::new(LazyExplode {})]);
+        test_dataframe_example(&mut engine_state, &LazyExplode.examples()[0]);
+    }
+
+    #[ignore]
+    #[test]
+    fn test_examples_expression() {
+        let mut engine_state = build_test_engine_state(vec![
+            Box::new(LazyExplode {}),
+            Box::new(LazyAggregate {}),
+            Box::new(ToLazyGroupBy {}),
+        ]);
+        test_dataframe_example(&mut engine_state, &LazyExplode.examples()[1]);
+    }
+}