remove std clip (#11131)

follow up to
- https://github.com/nushell/nushell/pull/11097

related to
- https://github.com/nushell/nu_scripts/pull/674

> **Important**
> wait for in between Nushell 0.88.0 and 0.89.0

# Description
this PR removes the `std clip` command after it's been deprecated in
https://github.com/nushell/nushell/pull/11097 😋

# User-Facing Changes
`std clip` will no longer be available.

# Tests + Formatting

# After Submitting

.cargo/config.toml

@@ -26,3 +26,8 @@ rustflags = ["-C", "link-args=-stack:10000000", "-C", "target-feature=+crt-stati
 # [target.aarch64-apple-darwin]
 # linker = "clang"
 # rustflags = ["-C", "link-arg=-fuse-ld=mold"]
+
+[target.aarch64-apple-darwin]
+# We can guarantee that this target will always run on a CPU with _at least_
+# these capabilities, so let's optimize for them
+rustflags = ["-Ctarget-cpu=apple-m1"]

.gitattributes

@@ -0,0 +1,2 @@
+# Example of a `.gitattributes` file which reclassifies `.nu` files as Nushell:
+*.nu linguist-language=Nushell

.github/.typos.toml

@@ -10,3 +10,6 @@ ba = "ba"
 Plasticos = "Plasticos"
 IIF = "IIF"
 numer = "numer"
+ratatui = "ratatui"
+doas = "doas"
+wheres = "wheres"

.github/AUTO_ISSUE_TEMPLATE/README.md

@@ -0,0 +1 @@
+This directory is intended for templates to automatically create issues with the [create-an-issue](https://github.com/JasonEtco/create-an-issue) action.

.github/AUTO_ISSUE_TEMPLATE/nightly-build-fail.md

@@ -0,0 +1,16 @@
+---
+name: Nightly build of release binaries failed
+about: Used to submit issues related to binaries release workflow
+title: 'Attention: Nightly build of release binaries failed'
+labels: ['build-package', 'priority']
+assignees: ''
+
+---
+
+**Nightly build of release binaries failed**
+
+Hi there:
+
+If you see me here that means there is a release failure for the nightly build
+
+Please **click the status badge** to see more details: [![Nightly Build](https://github.com/nushell/nushell/actions/workflows/nightly-build.yml/badge.svg)](https://github.com/nushell/nushell/actions/workflows/nightly-build.yml)

.github/pull_request_template.md

@@ -1,3 +1,11 @@
+<!--
+if this PR closes one or more issues, you can automatically link the PR with
+them by using one of the [*linking keywords*](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword), e.g.
+- this PR should close #xxxx
+- fixes #xxxx
+
+you can also mention related issues, PRs or discussions!
+-->
 
 # Description
 <!--
@@ -16,9 +24,9 @@ Don't forget to add tests that cover your changes.
 Make sure you've run and fixed any issues with these commands:
 
 - `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes)
-- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect -A clippy::result_large_err` to check that you're using the standard code style
-- `cargo test --workspace` to check that all tests pass
-- `cargo run -- crates/nu-std/tests/run.nu` to run the tests for the standard library
+- `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 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

@@ -0,0 +1,25 @@
+name: Security audit
+on:
+  pull_request:
+    paths:
+      - '**/Cargo.toml'
+      - '**/Cargo.lock'
+  push:
+    branches:
+    - main
+
+env:
+  RUST_BACKTRACE: 1
+  CARGO_TERM_COLOR: always
+  CLICOLOR: 1
+
+jobs:
+  security_audit:
+    runs-on: ubuntu-latest
+    # Prevent sudden announcement of a new advisory from failing ci:
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: rustsec/audit-check@v1.4.1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -1,13 +1,19 @@
 on:
   pull_request:
-  push: # Run CI on the main branch after every merge. This is important to fill the GitHub Actions cache in a way that pull requests can see it
+  push:
     branches:
       - main
 
 name: continuous-integration
 
+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"
+
 jobs:
-  nu-fmt-clippy:
+  fmt-clippy:
     strategy:
       fail-fast: true
       matrix:
@@ -15,194 +21,165 @@ jobs:
         # 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]
-        style: [default, dataframe]
-        rust:
-          - stable
+        feature: [default, dataframe, extra]
         include:
-          - style: default
+          - feature: default
             flags: ""
-          - style: dataframe
-            flags: "--features=dataframe "
+          - feature: dataframe
+            flags: "--features=dataframe"
+          - feature: extra
+            flags: "--features=extra"
         exclude:
-          # only test dataframes on Ubuntu (the fastest platform)
           - platform: windows-latest
-            style: dataframe
+            feature: dataframe
           - platform: macos-latest
-            style: dataframe
-
-
+            feature: dataframe
 
     runs-on: ${{ matrix.platform }}
-    env:
-      NUSHELL_CARGO_TARGET: ci
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.4.4
+        uses: actions-rust-lang/setup-rust-toolchain@v1.6.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 ${{ matrix.flags }}--exclude nu_plugin_* -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect -A clippy::result_large_err
+        run: cargo clippy --workspace ${{ matrix.flags }} --exclude nu_plugin_* -- $CLIPPY_OPTIONS
 
-  nu-tests:
-    env:
-      NUSHELL_CARGO_TARGET: ci
+        # In tests we don't have to deny unwrap
+      - name: Clippy of tests
+        run: cargo clippy --tests --workspace ${{ matrix.flags }} --exclude nu_plugin_* -- -D warnings
 
+  tests:
     strategy:
       fail-fast: true
       matrix:
         platform: [windows-latest, macos-latest, ubuntu-20.04]
-        style: [default, dataframe]
-        rust:
-          - stable
+        feature: [default, dataframe, extra]
         include:
-          - style: default
+          - feature: default
             flags: ""
-          - style: dataframe
+          - feature: dataframe
             flags: "--features=dataframe"
+          - feature: extra
+            flags: "--features=extra"
         exclude:
-          # only test dataframes on Ubuntu (the fastest platform)
           - platform: windows-latest
-            style: dataframe
+            feature: dataframe
           - platform: macos-latest
-            style: dataframe
+            feature: dataframe
+          - platform: windows-latest
+            feature: extra
+          - platform: macos-latest
+            feature: extra
 
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.4.4
+        uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+        with:
+          rustflags: ""
 
       - name: Tests
         run: cargo test --workspace --profile ci --exclude nu_plugin_* ${{ matrix.flags }}
 
-  std-lib-and-python-virtualenv:
-    env:
-      NU_LOG_LEVEL: DEBUG
+      - name: Check for clean repo
+        shell: bash
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            echo "there are changes";
+            git status --porcelain
+            exit 1
+          else
+            echo "no changes in working directory";
+          fi
 
+  std-lib-and-python-virtualenv:
     strategy:
       fail-fast: true
       matrix:
         platform: [ubuntu-20.04, macos-latest, windows-latest]
-        rust:
-          - stable
         py:
           - py
 
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.4.4
+        uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+        with:
+          rustflags: ""
 
       - name: Install Nushell
-        # prior to [*standard library: bring the tests into the main CI*](#8525)
-        # there was a `--profile ci` here in the `cargo install`, as well as
-        # `NUSHELL_CARGO_TARGET: ci` in the prelude above.
-        #
-        # this caused a "stackoverflow" error in the CI on windows,
-        # see [this failing job](https://github.com/nushell/nushell/actions/runs/4512034615/jobs/7944945590)
-        #
-        # the CI profile has been removed in 00b820de9021227d1910a9ea388297ee7aee308e
-        # as part of #8525.
         run: cargo install --path . --locked --no-default-features
 
       - name: Standard library tests
-        run: nu -c 'use std; std run-tests --path crates/nu-std'
+        run: nu -c 'use std testing; testing run-tests --path crates/nu-std'
 
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: "3.10"
 
-      - run: python -m pip install tox
-
-        # Get only the latest tagged version for stability reasons
       - name: Install virtualenv
-        run: git clone https://github.com/pypa/virtualenv.git
+        run: pip install virtualenv
         shell: bash
 
       - name: Test Nushell in virtualenv
-        run: |
-          cd virtualenv
-          # if we encounter problems with bleeding edge tests pin to the latest tag
-          # git checkout $(git describe --tags | cut -d - -f 1)
-          # We need to disable failing on coverage levels.
-          nu -c "open pyproject.toml | upsert tool.coverage.report.fail_under 1 | save patchproject.toml"
-          mv patchproject.toml pyproject.toml
-          tox -e ${{ matrix.py }} -- -k nushell
+        run: nu scripts/test_virtualenv.nu
         shell: bash
 
-  # Build+test plugins on their own, without the rest of Nu. This helps with CI parallelization and
-  # also helps test that the plugins build without any feature unification shenanigans
-  plugins:
-    env:
-      NUSHELL_CARGO_TARGET: ci
+      - name: Check for clean repo
+        shell: bash
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            echo "there are changes";
+            git status --porcelain
+            exit 1
+          else
+            echo "no changes in working directory";
+          fi
 
+  plugins:
     strategy:
       fail-fast: true
       matrix:
         platform: [windows-latest, macos-latest, ubuntu-20.04]
-        rust:
-          - stable
 
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.4.4
+        uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+        with:
+          rustflags: ""
 
       - name: Clippy
-        run: cargo clippy --package nu_plugin_* ${{ matrix.flags }} -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect -A clippy::result_large_err
+        run: cargo clippy --package nu_plugin_* ${{ matrix.flags }} -- $CLIPPY_OPTIONS
 
       - name: Tests
         run: cargo test --profile ci --package nu_plugin_*
 
-
-  nu-coverage:
-    if: false
-    env:
-      NUSHELL_CARGO_TARGET: ci
-
-    strategy:
-      fail-fast: true
-      matrix:
-        # disabled mac due to problems with merging coverage and similarity to linux
-        # disabled windows due to running out of disk space when having too many crates or tests
-        platform: [ubuntu-20.04] # windows-latest
-        rust:
-          - stable
-
-    runs-on: ${{ matrix.platform }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.4.4
-      - name: Install cargo-llvm-cov
-        uses: taiki-e/install-action@cargo-llvm-cov
-
-      - name: Tests
+      - name: Check for clean repo
         shell: bash
         run: |
-          source <(cargo llvm-cov show-env --export-prefix) # Set the environment variables needed to get coverage.
-          cargo llvm-cov clean --workspace # Remove artifacts that may affect the coverage results.
-          cargo build --workspace --profile ci
-          cargo test --workspace --profile ci
-          cargo llvm-cov report --profile ci --lcov --output-path lcov.info
-
-      - name: Upload coverage reports to Codecov with GitHub Action
-        uses: codecov/codecov-action@v3
-        with:
-          files: lcov.info
+          if [ -n "$(git status --porcelain)" ]; then
+            echo "there are changes";
+            git status --porcelain
+            exit 1
+          else
+            echo "no changes in working directory";
+          fi

.github/workflows/nightly-build.yml

@@ -0,0 +1,346 @@
+#
+# REF:
+#   1. https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstrategymatrixinclude
+#   2. https://github.com/JasonEtco/create-an-issue
+#   3. https://docs.github.com/en/actions/learn-github-actions/variables
+#   4. https://github.com/actions/github-script
+#
+name: Nightly Build
+
+on:
+  push:
+    branches:
+      - nightly   # Just for test purpose only with the nightly repo
+  # This schedule will run only from the default branch
+  schedule:
+    - cron: '15 0 * * *' # run at 00:15 AM UTC
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  prepare:
+    name: Prepare
+    runs-on: ubuntu-latest
+    # This job is required by the release job, so we should make it run both from Nushell repo and nightly repo
+    # if: github.repository == 'nushell/nightly'
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        if: github.repository == 'nushell/nightly'
+        with:
+          ref: main
+          fetch-depth: 0
+          # Configure PAT here: https://github.com/settings/tokens for the push operation in the following steps
+          token: ${{ secrets.WORKFLOW_TOKEN }}
+
+      - name: Setup Nushell
+        uses: hustcer/setup-nu@v3.8
+        if: github.repository == 'nushell/nightly'
+        with:
+          version: 0.86.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # Synchronize the main branch of nightly repo with the main branch of Nushell official repo
+      - name: Prepare for Nightly Release
+        shell: nu {0}
+        if: github.repository == 'nushell/nightly'
+        run: |
+          cd $env.GITHUB_WORKSPACE
+          git checkout main
+          # We can't push if no user name and email are configured
+          git config user.name 'hustcer'
+          git config user.email 'hustcer@outlook.com'
+          git pull origin main
+          git remote add src https://github.com/nushell/nushell.git
+          git fetch src main
+          # All the changes will be overwritten by the upstream main branch
+          git reset --hard src/main
+          git push origin main -f
+          let sha_short = (git rev-parse --short origin/main | str trim | str substring 0..7)
+          let tag_name = $'nightly-($sha_short)'
+          if (git ls-remote --tags origin $tag_name | is-empty) {
+            git tag -a $tag_name -m $'Nightly build from ($sha_short)'
+            git push origin --tags
+          }
+
+  standard:
+    name: Std
+    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
+        - armv7-unknown-linux-gnueabihf
+        - riscv64gc-unknown-linux-gnu
+        extra: ['bin']
+        include:
+        - target: aarch64-apple-darwin
+          os: macos-latest
+          target_rustflags: ''
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: ''
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: ''
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: ''
+        - target: 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
+      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.6.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.8
+      with:
+        version: 0.86.0
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - 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() }}
+      uses: JasonEtco/create-an-issue@v2.9.1
+      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@v0.1.15
+      if: ${{ startsWith(github.repository, 'nushell/nightly') }}
+      with:
+        prerelease: true
+        files: ${{ steps.nu.outputs.archive }}
+        tag_name: nightly-${{ steps.vars.outputs.sha_short }}
+        name: Nu-nightly-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.sha_short }}
+      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,extra'
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-unknown-linux-musl
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+    - uses: actions/checkout@v4
+      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.6.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.8
+      with:
+        version: 0.86.0
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - 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.1
+      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@v0.1.15
+      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
+    if: github.repository == 'nushell/nightly'
+    runs-on: ubuntu-latest
+    steps:
+      # Sleep for 30 minutes, waiting for the release to be published
+      - name: Waiting for Release
+        run: sleep 1800
+
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+
+      - name: Setup Nushell
+        uses: hustcer/setup-nu@v3.8
+        with:
+          version: 0.86.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # Keep the last a few releases
+      - name: Delete Older Releases
+        shell: nu {0}
+        run: |
+          let KEEP_COUNT = 10
+          let deprecated = (http get https://api.github.com/repos/nushell/nightly/releases | sort-by -r created_at | select tag_name id | range $KEEP_COUNT..)
+          for release in $deprecated {
+            print $'Deleting tag ($release.tag_name)'
+            git push origin --delete $release.tag_name
+            print $'Deleting release ($release.tag_name)'
+            let delete_url = $'https://api.github.com/repos/nushell/nightly/releases/($release.id)'
+            let version = "X-GitHub-Api-Version: 2022-11-28"
+            let accept = "Accept: application/vnd.github+json"
+            let auth = "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}"
+            # http delete $delete_url -H $version -H $auth -H $accept
+            curl -L -X DELETE -H $accept -H $auth -H $version $delete_url
+          }

.github/workflows/release-pkg.nu

@@ -9,34 +9,36 @@
 # 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.76.0
+# 1. git checkout 0.86.0
 # unset CARGO_TARGET_DIR if set (I have to do this in the parent shell to get it to work)
 # 2. $env:CARGO_TARGET_DIR = ""
 # 2. hide-env CARGO_TARGET_DIR
-# 3. let-env TARGET = 'x86_64-pc-windows-msvc'
-# 4. let-env TARGET_RUSTFLAGS = ''
-# 5. let-env GITHUB_WORKSPACE = 'C:\Users\dschroeder\source\repos\forks\nushell'
-# 6. let-env GITHUB_OUTPUT = 'C:\Users\dschroeder\source\repos\forks\nushell\output\out.txt'
-# 7. let-env OS = 'windows-latest'
+# 3. $env.TARGET = 'x86_64-pc-windows-msvc'
+# 4. $env.TARGET_RUSTFLAGS = ''
+# 5. $env.GITHUB_WORKSPACE = 'D:\nushell'
+# 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
-# 8. let-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
-# 9. let-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/
-# 10. let-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'
-# 11. let-env _EXTRA_ = 'bin'
-# 12. source .github\workflows\release-pkg.nu
-# 13. cd ..
-# 14. let-env _EXTRA_ = 'msi'
-# 15. source .github\workflows\release-pkg.nu
+# 12. $env._EXTRA_ = 'bin'
+# 13. source .github\workflows\release-pkg.nu
+# 14. cd ..
+# 15. $env._EXTRA_ = 'msi'
+# 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
-# 16. 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
 
 
@@ -51,11 +53,26 @@ 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, flags: $flags, 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 = 'ubuntu-20.04'
+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 }
@@ -65,21 +82,31 @@ print $'Start building ($bin)...'; hr-line
 # ----------------------------------------------------------------------------
 # Build for Ubuntu and macOS
 # ----------------------------------------------------------------------------
-if $os in [$USE_UBUNTU, 'macos-latest'] {
-    if $os == $USE_UBUNTU {
+if $os in [$USE_UBUNTU, 'macos-latest', 'ubuntu-latest'] {
+    if $os starts-with ubuntu {
         sudo apt update
         sudo apt-get install libxcb-composite0-dev -y
     }
     match $target {
         'aarch64-unknown-linux-gnu' => {
             sudo apt-get install gcc-aarch64-linux-gnu -y
-            let-env CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER = 'aarch64-linux-gnu-gcc'
+            $env.CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER = 'aarch64-linux-gnu-gcc'
+            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 $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 $flags
         }
         _ => {
             # musl-tools to fix 'Failed to find tool. Is `musl-gcc` installed?'
             # Actually just for x86_64-unknown-linux-musl target
-            if $os == $USE_UBUNTU { sudo apt install musl-tools -y }
+            if $os starts-with ubuntu { sudo apt install musl-tools -y }
             cargo-build-nu $flags
         }
     }
@@ -89,12 +116,7 @@ if $os in [$USE_UBUNTU, 'macos-latest'] {
 # Build for Windows without static-link-openssl feature
 # ----------------------------------------------------------------------------
 if $os in ['windows-latest'] {
-    # let-env CARGO_BUILD_TARGET = $target
-    if ($flags | str trim | is-empty) {
-        cargo build --release --all --target $target
-    } else {
-        cargo build --release --all --target $target $flags
-    }
+    cargo-build-nu $flags
 }
 
 # ----------------------------------------------------------------------------
@@ -114,10 +136,8 @@ print (ls -f $executable); sleep 1sec
 print $'(char nl)Copying release files...'; hr-line
 "To use Nu plugins, use the register command to tell Nu where to find the plugin. For example:
 
-> register ./nu_plugin_query" | save $'($dist)/README.txt'
+> register ./nu_plugin_query" | save $'($dist)/README.txt' -f
 [LICENSE $executable] | each {|it| cp -rv $it $dist } | flatten
-# Sleep a few seconds to make sure the cp process finished successfully
-sleep 3sec
 
 print $'(char nl)Check binary release version detail:'; hr-line
 let ver = if $os == 'windows-latest' {
@@ -126,17 +146,17 @@ let ver = if $os == 'windows-latest' {
     (do -i { ./output/nu -c 'version' }) | str join
 }
 if ($ver | str trim | is-empty) {
-    print $'(ansi r)Incompatible nu binary...(ansi reset)'
+    print $'(ansi r)Incompatible Nu binary: The binary cross compiled is not runnable on current arch...(ansi reset)'
 } else { print $ver }
 
 # ----------------------------------------------------------------------------
 # Create a release archive and send it to output for the following steps
 # ----------------------------------------------------------------------------
 cd $dist; print $'(char nl)Creating release archive...'; hr-line
-if $os in [$USE_UBUNTU, 'macos-latest'] {
+if $os in [$USE_UBUNTU, 'macos-latest', 'ubuntu-latest'] {
 
     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
@@ -151,7 +171,7 @@ if $os in [$USE_UBUNTU, 'macos-latest'] {
 
 } 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
@@ -167,33 +187,45 @@ if $os in [$USE_UBUNTU, 'macos-latest'] {
         cp -r $'($dist)/*' target/release/
         cargo install cargo-wix --version 0.3.4
         cargo wix --no-build --nocapture --package nu --output $wixRelease
-        print $'archive: ---> ($wixRelease)';
-        echo $"archive=($wixRelease)" | save --append $env.GITHUB_OUTPUT
+        # Workaround for https://github.com/softprops/action-gh-release/issues/280
+        let archive = ($wixRelease | str replace --all '\' '/')
+        print $'archive: ---> ($archive)';
+        echo $"archive=($archive)" | save --append $env.GITHUB_OUTPUT
 
     } else {
 
         print $'(char nl)(ansi g)Archive contents:(ansi reset)'; hr-line; ls
         let archive = $'($dist)/($releaseStem).zip'
         7z a $archive *
-        print $'archive: ---> ($archive)';
         let pkg = (ls -f $archive | get name)
         if not ($pkg | is-empty) {
-            echo $"archive=($pkg | get 0)" | save --append $env.GITHUB_OUTPUT
+            # Workaround for https://github.com/softprops/action-gh-release/issues/280
+            let archive = ($pkg | get 0 | str replace --all '\' '/')
+            print $'archive: ---> ($archive)'
+            echo $"archive=($archive)" | save --append $env.GITHUB_OUTPUT
         }
     }
 }
 
 def 'cargo-build-nu' [ options: string ] {
     if ($options | str trim | is-empty) {
-        cargo build --release --all --target $target --features=static-link-openssl
+        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 $options
+        if $os == 'windows-latest' {
+            cargo build --release --all --target $target $options
+        } else {
+            cargo build --release --all --target $target --features=static-link-openssl $options
+        }
     }
 }
 
 # Print a horizontal line marker
 def 'hr-line' [
-    --blank-line(-b): bool
+    --blank-line(-b)
 ] {
     print $'(ansi g)---------------------------------------------------------------------------->(ansi reset)'
     if $blank_line { char nl }

.github/workflows/release.yml

@@ -14,8 +14,8 @@ defaults:
     shell: bash
 
 jobs:
-  all:
-    name: All
+  standard:
+    name: Std
 
     strategy:
       matrix:
@@ -27,6 +27,8 @@ jobs:
         - x86_64-unknown-linux-gnu
         - x86_64-unknown-linux-musl
         - aarch64-unknown-linux-gnu
+        - armv7-unknown-linux-gnueabihf
+        - riscv64gc-unknown-linux-gnu
         extra: ['bin']
         include:
         - target: aarch64-apple-darwin
@@ -60,23 +62,32 @@ jobs:
         - 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@v3
+    - uses: actions/checkout@v4
 
     - 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.4.4
+      uses: actions-rust-lang/setup-rust-toolchain@v1.6.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
+      uses: hustcer/setup-nu@v3.8
       with:
-        version: 0.79.0
+        version: 0.86.0
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -84,6 +95,7 @@ jobs:
       id: nu
       run: nu .github/workflows/release-pkg.nu
       env:
+        RELEASE_TYPE: standard
         OS: ${{ matrix.os }}
         REF: ${{ github.ref }}
         TARGET: ${{ matrix.target }}
@@ -92,7 +104,98 @@ jobs:
 
     # REF: https://github.com/marketplace/actions/gh-release
     - name: Publish Archive
-      uses: softprops/action-gh-release@v0.1.13
+      uses: softprops/action-gh-release@v0.1.15
+      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,extra'
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-unknown-linux-musl
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - 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.6.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.8
+      with:
+        version: 0.86.0
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - 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@v0.1.15
       if: ${{ startsWith(github.ref, 'refs/tags/') }}
       with:
         draft: true

.github/workflows/typos.yml

@@ -7,7 +7,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Actions Repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Check spelling
-        uses: crate-ci/typos@master
+        uses: crate-ci/typos@v1.17.0
+        with:
+          config: ./.github/.typos.toml

.github/workflows/winget-submission.yml

@@ -7,19 +7,22 @@ on:
     inputs:
       tag_name:
         description: 'Specific tag name'
-        required: true 
+        required: true
         type: string
 
 jobs:
 
   winget:
     name: Publish winget package
-    runs-on: windows-latest
+    runs-on: ubuntu-latest
     steps:
       - name: Submit package to Windows Package Manager Community Repository
         uses: vedantmgoyal2009/winget-releaser@v2
         with:
           identifier: Nushell.Nushell
+          # Exclude all `*-msvc-full.msi` full release files,
+          # and only the default `*msvc.msi` files will be included
+          installers-regex: 'msvc\.msi$'
           version: ${{ inputs.tag_name || github.event.release.tag_name }}
           release-tag: ${{ inputs.tag_name || github.event.release.tag_name }}
           token: ${{ secrets.NUSHELL_PAT }}

.gitignore

@@ -42,6 +42,7 @@ tarpaulin-report.html
 *.rsproj
 *.rsproj.user
 *.sln
+*.code-workspace
 
 # direnv
 .direnv/

CONTRIBUTING.md

@@ -2,7 +2,25 @@
 
 Welcome to Nushell and thank you for considering contributing!
 
-## Review Process
+## Table of contents
+- [Proposing design changes](#proposing-design-changes)
+- [Developing](#developing)
+  - [Setup](#setup)
+  - [Tests](#tests)
+  - [Useful commands](#useful-commands)
+  - [Debugging tips](#debugging-tips)
+- [Git etiquette](#git-etiquette)
+- [License](#license)
+
+## Other helpful resources
+
+More resources can be found in the nascent [developer documentation](devdocs/README.md) in this repo.
+
+- [Developer FAQ](FAQ.md)
+- [Platform support policy](PLATFORM_SUPPORT.md)
+- [Our Rust style](devdocs/rust_style.md)
+
+## Proposing design changes
 
 First of all, before diving into the code, if you want to create a new feature, change something significantly, and especially if the change is user-facing, it is a good practice to first get an approval from the core team before starting to work on it.
 This saves both your and our time if we realize the change needs to go another direction before spending time on it.
@@ -33,7 +51,7 @@ cargo build
 
 ### Tests
 
-It is a good practice to cover your changes with a test. Also, try to think about corner cases and various ways how your changes could break. Cover those in the tests as well.
+It is good practice to cover your changes with a test. Also, try to think about corner cases and various ways how your changes could break. Cover those in the tests as well.
 
 Tests can be found in different places:
 * `/tests`
@@ -41,80 +59,83 @@ Tests can be found in different places:
 * command examples
 * crate-specific tests
 
-The most comprehensive test suite we have is the `nu-test-support` crate. For testing specific features, such as running Nushell in a REPL mode, we have so called "testbins". For simple tests, you can find `run_test()` and `fail_test()` functions.
+Most of the tests are built upon the `nu-test-support` crate. For testing specific features, such as running Nushell in a REPL mode, we have so called "testbins". For simple tests, you can find `run_test()` and `fail_test()` functions.
 
 ### Useful Commands
 
+As Nushell is built using a cargo workspace consisting of multiple crates keep in mind that you may need to pass additional flags compared to how you may be used to it from a single crate project.
+Read cargo's documentation for more details: https://doc.rust-lang.org/cargo/reference/workspaces.html
+
 - Build and run Nushell:
 
-  ```shell
+  ```nushell
   cargo run
   ```
 
 - Build and run with dataframe support.
-  ```shell
+  ```nushell
   cargo run --features=dataframe
   ```
 
 - Run Clippy on Nushell:
 
-  ```shell
-  cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect -A clippy::result_large_err
+  ```nushell
+  cargo clippy --workspace -- -D warnings -D clippy::unwrap_used
   ```
   or via the `toolkit.nu` command:
-  ```shell
+  ```nushell
   use toolkit.nu clippy
   clippy
   ```
 
 - Run all tests:
 
-  ```shell
+  ```nushell
   cargo test --workspace
   ```
 
   along with dataframe tests
 
-  ```shell
+  ```nushell
   cargo test --workspace --features=dataframe
   ```
   or via the `toolkit.nu` command:
-  ```shell
+  ```nushell
   use toolkit.nu test
   test
   ```
 
 - Run all tests for a specific command
 
-  ```shell
+  ```nushell
   cargo test --package nu-cli --test main -- commands::<command_name_here>
   ```
 
 - Check to see if there are code formatting issues
 
-  ```shell
+  ```nushell
   cargo fmt --all -- --check
   ```
   or via the `toolkit.nu` command:
-  ```shell
+  ```nushell
   use toolkit.nu fmt
   fmt --check
   ```
 
 - Format the code in the project
 
-  ```shell
+  ```nushell
   cargo fmt --all
   ```
   or via the `toolkit.nu` command:
-  ```shell
+  ```nushell
   use toolkit.nu fmt
   fmt
   ```
 
 - Set up `git` hooks to check formatting and run `clippy` before committing and pushing:
 
-  ```shell
+  ```nushell
   use toolkit.nu setup-git-hooks
   setup-git-hooks
   ```
@@ -124,12 +145,12 @@ The most comprehensive test suite we have is the `nu-test-support` crate. For te
 
 - To view verbose logs when developing, enable the `trace` log level.
 
-  ```shell
+  ```nushell
   cargo run --release -- --log-level trace
   ```
 
 - To redirect trace logs to a file, enable the `--log-target file` switch.
-  ```shell
+  ```nushell
   cargo run --release -- --log-level trace --log-target file
   open $"($nu.temp-path)/nu-($nu.pid).log"
   ```
@@ -220,3 +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

@@ -10,8 +10,8 @@ homepage = "https://www.nushell.sh"
 license = "MIT"
 name = "nu"
 repository = "https://github.com/nushell/nushell"
-rust-version = "1.60"
-version = "0.81.0"
+rust-version = "1.72.1"
+version = "0.88.2"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -28,10 +28,16 @@ members = [
 	"crates/nu-engine",
 	"crates/nu-parser",
 	"crates/nu-system",
+	"crates/nu-cmd-base",
 	"crates/nu-cmd-extra",
 	"crates/nu-cmd-lang",
 	"crates/nu-cmd-dataframe",
 	"crates/nu-command",
+	"crates/nu-color-config",
+	"crates/nu-explore",
+	"crates/nu-json",
+	"crates/nu-lsp",
+	"crates/nu-pretty-hex",
 	"crates/nu-protocol",
 	"crates/nu-plugin",
 	"crates/nu_plugin_inc",
@@ -41,34 +47,42 @@ members = [
 	"crates/nu_plugin_custom_values",
 	"crates/nu_plugin_formats",
 	"crates/nu-std",
+	"crates/nu-table",
+	"crates/nu-term-grid",
 	"crates/nu-utils",
 ]
 
 [dependencies]
-nu-cli = { path = "./crates/nu-cli", version = "0.81.0" }
-nu-color-config = { path = "./crates/nu-color-config", version = "0.81.0" }
-nu-cmd-lang = { path = "./crates/nu-cmd-lang", version = "0.81.0" }
-nu-cmd-dataframe = { path = "./crates/nu-cmd-dataframe", version = "0.81.0", optional = true }
-nu-command = { path = "./crates/nu-command", version = "0.81.0" }
-nu-engine = { path = "./crates/nu-engine", version = "0.81.0" }
-nu-json = { path = "./crates/nu-json", version = "0.81.0" }
-nu-parser = { path = "./crates/nu-parser", version = "0.81.0" }
-nu-path = { path = "./crates/nu-path", version = "0.81.0" }
-nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.81.0" }
-nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.81.0" }
-nu-protocol = { path = "./crates/nu-protocol", version = "0.81.0" }
-nu-system = { path = "./crates/nu-system", version = "0.81.0" }
-nu-table = { path = "./crates/nu-table", version = "0.81.0" }
-nu-term-grid = { path = "./crates/nu-term-grid", version = "0.81.0" }
-nu-std = { path = "./crates/nu-std", version = "0.81.0" }
-nu-utils = { path = "./crates/nu-utils", version = "0.81.0" }
-nu-ansi-term = "0.47.0"
-reedline = { version = "0.20.0", features = ["bashisms", "sqlite"]}
+nu-cli = { path = "./crates/nu-cli", version = "0.88.2" }
+nu-color-config = { path = "./crates/nu-color-config", version = "0.88.2" }
+nu-cmd-base = { path = "./crates/nu-cmd-base", version = "0.88.2" }
+nu-cmd-lang = { path = "./crates/nu-cmd-lang", version = "0.88.2" }
+nu-cmd-dataframe = { path = "./crates/nu-cmd-dataframe", version = "0.88.2", features = ["dataframe"], optional = true }
+nu-cmd-extra = { path = "./crates/nu-cmd-extra", version = "0.88.2", optional = true }
+nu-command = { path = "./crates/nu-command", version = "0.88.2" }
+nu-engine = { path = "./crates/nu-engine", version = "0.88.2" }
+nu-explore = { path = "./crates/nu-explore", version = "0.88.2" }
+nu-json = { path = "./crates/nu-json", version = "0.88.2" }
+nu-lsp = { path = "./crates/nu-lsp/", version = "0.88.2" }
+nu-parser = { path = "./crates/nu-parser", version = "0.88.2" }
+nu-path = { path = "./crates/nu-path", version = "0.88.2" }
+nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.88.2" }
+nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.88.2" }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.88.2" }
+nu-system = { path = "./crates/nu-system", version = "0.88.2" }
+nu-table = { path = "./crates/nu-table", version = "0.88.2" }
+nu-term-grid = { path = "./crates/nu-term-grid", version = "0.88.2" }
+nu-std = { path = "./crates/nu-std", version = "0.88.2" }
+nu-utils = { path = "./crates/nu-utils", version = "0.88.2" }
 
-crossterm = "0.26"
-ctrlc = "3.2"
+nu-ansi-term = "0.49.0"
+reedline = { version = "0.27.0", features = ["bashisms", "sqlite"] }
+
+crossterm = "0.27"
+ctrlc = "3.4"
 log = "0.4"
-miette = { version = "5.9", features = ["fancy-no-backtrace"] }
+miette = { version = "5.10", features = ["fancy-no-backtrace"] }
+mimalloc = { version = "0.1.37", default-features = false, optional = true }
 serde_json = "1.0"
 simplelog = "0.12"
 time = "0.3"
@@ -82,22 +96,21 @@ signal-hook = { version = "0.3", default-features = false }
 winresource = "0.1"
 
 [target.'cfg(target_family = "unix")'.dependencies]
-nix = { version = "0.26", default-features = false, features = [
+nix = { version = "0.27", default-features = false, features = [
 	"signal",
 	"process",
 	"fs",
 	"term",
 ] }
-atty = "0.2"
 
 [dev-dependencies]
-nu-test-support = { path = "./crates/nu-test-support", version = "0.81.0" }
-tempfile = "3.5"
+nu-test-support = { path = "./crates/nu-test-support", version = "0.88.2" }
 assert_cmd = "2.0"
-criterion = "0.4"
-pretty_assertions = "1.0"
-serial_test = "1.0"
-rstest = { version = "0.17", default-features = false }
+criterion = "0.5"
+pretty_assertions = "1.4"
+rstest = { version = "0.18", default-features = false }
+serial_test = "2.0"
+tempfile = "3.8"
 
 [features]
 plugin = [
@@ -108,22 +121,26 @@ plugin = [
 	"nu-protocol/plugin",
 	"nu-engine/plugin",
 ]
-default = ["plugin", "which-support", "trash-support", "sqlite"]
+default = ["plugin", "which-support", "trash-support", "sqlite", "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; otherwise the system version will be used. Not enabled by default because it takes a while to build
+# Enable to statically link OpenSSL (perl is required, to build OpenSSL https://docs.rs/openssl/latest/openssl/);
+# otherwise the system version will be used. Not enabled by default because it takes a while to build
 static-link-openssl = ["dep:openssl", "nu-cmd-lang/static-link-openssl"]
 
+mimalloc = ["nu-cmd-lang/mimalloc", "dep:mimalloc"]
+
 # Stable (Default)
 which-support = ["nu-command/which-support", "nu-cmd-lang/which-support"]
 trash-support = ["nu-command/trash-support", "nu-cmd-lang/trash-support"]
 
 # Extra feature for nushell
-extra = ["nu-command/extra", "nu-cmd-lang/extra"]
+extra = ["dep:nu-cmd-extra", "nu-cmd-lang/extra"]
 
 # Dataframe feature for nushell
-dataframe = ["nu-command/dataframe", "nu-cmd-lang/dataframe"]
+dataframe = ["dep:nu-cmd-dataframe", "nu-cmd-lang/dataframe"]
 
 # SQLite commands for nushell
 sqlite = ["nu-command/sqlite", "nu-cmd-lang/sqlite"]
@@ -156,8 +173,9 @@ bench = false
 # To use a development version of a dependency please use a global override here
 # changing versions in each sub-crate of the workspace is tedious
 [patch.crates-io]
-# reedline = { git = "https://github.com/nushell/reedline.git", branch = "main"}
+reedline = { git = "https://github.com/nushell/reedline.git", branch = "main" }
 # nu-ansi-term = {git = "https://github.com/nushell/nu-ansi-term.git", branch = "main"}
+# uu_cp = { git = "https://github.com/uutils/coreutils.git", branch = "main" }
 
 # Criterion benchmarking setup
 # Run all benchmarks with `cargo bench`

Cross.toml

@@ -1,9 +1,18 @@
 # Configuration for cross-rs: https://github.com/cross-rs/cross
 # Run cross-rs like this:
-# cross build --target aarch64-unknown-linux-musl --release
+# cross build --target aarch64-unknown-linux-gnu --release
+# or
+# cross build --target aarch64-unknown-linux-musl --release --features=static-link-openssl
 
 [target.aarch64-unknown-linux-gnu]
-dockerfile = "./docker/cross-rs/aarch64-unknown-linux-gnu.dockerfile"
+pre-build = [
+    "dpkg --add-architecture $CROSS_DEB_ARCH",
+    "apt-get update && apt-get install --assume-yes libssl-dev:$CROSS_DEB_ARCH clang"
+]
 
+#  NOTE: for musl you will need to build with --features=static-link-openssl
 [target.aarch64-unknown-linux-musl]
-dockerfile = "./docker/cross-rs/aarch64-unknown-linux-musl.dockerfile"
+pre-build = [
+    "dpkg --add-architecture $CROSS_DEB_ARCH",
+    "apt-get update && apt-get install --assume-yes clang"
+]

README.md

@@ -1,12 +1,12 @@
 # Nushell <!-- omit in toc -->
 [![Crates.io](https://img.shields.io/crates/v/nu.svg)](https://crates.io/crates/nu)
 [![Build Status](https://img.shields.io/github/actions/workflow/status/nushell/nushell/ci.yml?branch=main)](https://github.com/nushell/nushell/actions)
+[![Nightly Build](https://github.com/nushell/nushell/actions/workflows/nightly-build.yml/badge.svg)](https://github.com/nushell/nushell/actions/workflows/nightly-build.yml)
 [![Discord](https://img.shields.io/discord/601130461678272522.svg?logo=discord)](https://discord.gg/NtAbbGn)
 [![The Changelog #363](https://img.shields.io/badge/The%20Changelog-%23363-61c192.svg)](https://changelog.com/podcast/363)
 [![@nu_shell](https://img.shields.io/badge/twitter-@nu_shell-1DA1F3?style=flat-square)](https://twitter.com/nu_shell)
 [![GitHub commit activity](https://img.shields.io/github/commit-activity/m/nushell/nushell)](https://github.com/nushell/nushell/graphs/commit-activity)
 [![GitHub contributors](https://img.shields.io/github/contributors/nushell/nushell)](https://github.com/nushell/nushell/graphs/contributors)
-[![codecov](https://codecov.io/gh/nushell/nushell/branch/main/graph/badge.svg?token=JheS8qu2II)](https://codecov.io/gh/nushell/nushell)
 
 A new type of shell.
 
@@ -23,7 +23,6 @@ A new type of shell.
   - [Opening files](#opening-files)
   - [Plugins](#plugins)
 - [Goals](#goals)
-- [Progress](#progress)
 - [Officially Supported By](#officially-supported-by)
 - [Contributing](#contributing)
 - [License](#license)
@@ -55,6 +54,7 @@ Detailed installation instructions can be found in the [installation chapter of
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/nushell.svg)](https://repology.org/project/nushell/versions)
 
+For details about which platforms the Nushell team actively supports, see [our platform support policy](devdocs/PLATFORM_SUPPORT.md).
 
 ## Configuration
 
@@ -199,7 +199,7 @@ topics that have been presented.
 
 Nu adheres closely to a set of goals that make up its design philosophy. As features are added, they are checked against these goals.
 
--   First and foremost, Nu is cross-platform. Commands and techniques should work across platforms and Nu has first-class support for Windows, macOS, and Linux.
+-   First and foremost, Nu is cross-platform. Commands and techniques should work across platforms and Nu has [first-class support for Windows, macOS, and Linux](devdocs/PLATFORM_SUPPORT.md).
 
 -   Nu ensures compatibility with existing platform-specific executables.
 
@@ -209,27 +209,6 @@ Nu adheres closely to a set of goals that make up its design philosophy. As feat
 
 -   Finally, Nu views data functionally. Rather than using mutation, pipelines act as a means to load, change, and save data without mutable state.
 
-## Progress
-
-Nu is under heavy development and will naturally change as it matures. The chart below isn't meant to be exhaustive, but it helps give an idea for some of the areas of development and their relative maturity:
-
-| Features      | Not started | Prototype | MVP | Preview | Mature | Notes                                                                |
-| ------------- | :---------: | :-------: | :-: | :-----: | :----: | -------------------------------------------------------------------- |
-| Aliases       |             |           |     |    X    |        | Aliases allow for shortening large commands, while passing flags     |
-| Notebook      |             |     X     |     |         |        | Initial jupyter support, but it loses state and lacks features       |
-| File ops      |             |           |     |    X    |        | cp, mv, rm, mkdir have some support, but lacking others              |
-| Environment   |             |           |     |    X    |        | Temporary environment and scoped environment variables               |
-| Shells        |             |           |     |    X    |        | Basic value and file shells, but no opt-in/opt-out for commands      |
-| Protocol      |             |           |     |    X    |        | Streaming protocol is serviceable                                    |
-| Plugins       |             |           |  X  |         |        | Plugins work on one row at a time, lack batching and expression eval |
-| Errors        |             |           |     |    X    |        | Error reporting works, but could use usability polish                |
-| Documentation |             |           |  X  |         |        | Book updated to latest release, including usage examples             |
-| Paging        |             |           |     |    X    |        | Textview has paging, but we'd like paging for tables                 |
-| Functions     |             |           |     |    X    |        | Functions and aliases are supported                                  |
-| Variables     |             |           |     |    X    |        | Nu supports variables and environment variables                      |
-| Completions   |             |           |     |    X    |        | Completions for filepaths                                            |
-| Type-checking |             |           |     |    x    |        | Commands check basic types, and input/output types                   |
-
 ## Officially Supported By
 
 Please submit an issue or PR to be added to this list.
@@ -240,13 +219,16 @@ Please submit an issue or PR to be added to this list.
 -   [Couchbase Shell](https://couchbase.sh)
 -   [virtualenv](https://github.com/pypa/virtualenv)
 -   [atuin](https://github.com/ellie/atuin)
+-   [clap](https://github.com/clap-rs/clap/tree/master/clap_complete_nushell)
+-   [Dorothy](http://github.com/bevry/dorothy)
+-   [Direnv](https://github.com/direnv/direnv/blob/master/docs/hook.md#nushell)
 
 ## Contributing
 
 See [Contributing](CONTRIBUTING.md) for details. Thanks to all the people who already contributed!
 
 <a href="https://github.com/nushell/nushell/graphs/contributors">
-  <img src="https://contributors-img.web.app/image?repo=nushell/nushell&max=500" />
+  <img src="https://contributors-img.web.app/image?repo=nushell/nushell&max=600" />
 </a>
 
 ## License

benches/benchmarks.rs

@@ -2,8 +2,32 @@ use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use nu_cli::eval_source;
 use nu_parser::parse;
 use nu_plugin::{EncodingType, PluginResponse};
-use nu_protocol::{PipelineData, Span, Value};
+use nu_protocol::{engine::EngineState, PipelineData, Span, Value};
 use nu_utils::{get_default_config, get_default_env};
+use std::path::{Path, PathBuf};
+
+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()
+}
 
 // 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
@@ -11,11 +35,13 @@ use nu_utils::{get_default_config, get_default_env};
 // a way to split things up again.
 
 fn parser_benchmarks(c: &mut Criterion) {
-    let mut engine_state = nu_command::create_default_context();
-    // parsing config.nu breaks without PWD set
+    let mut engine_state = load_bench_commands();
+    let home_path = get_home_path(&engine_state);
+
+    // parsing config.nu breaks without PWD set, so set a valid path
     engine_state.add_env_var(
         "PWD".into(),
-        Value::string("/some/dir".to_string(), Span::test_data()),
+        Value::string(home_path.to_string_lossy(), Span::test_data()),
     );
 
     let default_env = get_default_env().as_bytes();
@@ -38,7 +64,6 @@ fn parser_benchmarks(c: &mut Criterion) {
 
     c.bench_function("eval default_env.nu", |b| {
         b.iter(|| {
-            let mut engine_state = nu_command::create_default_context();
             let mut stack = nu_protocol::engine::Stack::new();
             eval_source(
                 &mut engine_state,
@@ -53,12 +78,6 @@ fn parser_benchmarks(c: &mut Criterion) {
 
     c.bench_function("eval default_config.nu", |b| {
         b.iter(|| {
-            let mut engine_state = nu_command::create_default_context();
-            // parsing config.nu breaks without PWD set
-            engine_state.add_env_var(
-                "PWD".into(),
-                Value::string("/some/dir".to_string(), Span::test_data()),
-            );
             let mut stack = nu_protocol::engine::Stack::new();
             eval_source(
                 &mut engine_state,
@@ -73,9 +92,17 @@ fn parser_benchmarks(c: &mut Criterion) {
 }
 
 fn eval_benchmarks(c: &mut Criterion) {
+    let mut engine_state = load_bench_commands();
+    let home_path = get_home_path(&engine_state);
+
+    // parsing config.nu breaks without PWD set, so set a valid path
+    engine_state.add_env_var(
+        "PWD".into(),
+        Value::string(home_path.to_string_lossy(), Span::test_data()),
+    );
+
     c.bench_function("eval default_env.nu", |b| {
         b.iter(|| {
-            let mut engine_state = nu_command::create_default_context();
             let mut stack = nu_protocol::engine::Stack::new();
             eval_source(
                 &mut engine_state,
@@ -90,12 +117,6 @@ fn eval_benchmarks(c: &mut Criterion) {
 
     c.bench_function("eval default_config.nu", |b| {
         b.iter(|| {
-            let mut engine_state = nu_command::create_default_context();
-            // parsing config.nu breaks without PWD set
-            engine_state.add_env_var(
-                "PWD".into(),
-                Value::string("/some/dir".to_string(), Span::test_data()),
-            );
             let mut stack = nu_protocol::engine::Stack::new();
             eval_source(
                 &mut engine_state,
@@ -111,30 +132,18 @@ fn eval_benchmarks(c: &mut Criterion) {
 
 // generate a new table data with `row_cnt` rows, `col_cnt` columns.
 fn encoding_test_data(row_cnt: usize, col_cnt: usize) -> Value {
-    let columns: Vec<String> = (0..col_cnt).map(|x| format!("col_{x}")).collect();
-    let vals: Vec<Value> = (0..col_cnt as i64).map(Value::test_int).collect();
-
-    Value::List {
-        vals: (0..row_cnt)
-            .map(|_| Value::test_record(columns.clone(), vals.clone()))
+    let record = Value::test_record(
+        (0..col_cnt)
+            .map(|x| (format!("col_{x}"), Value::test_int(x as i64)))
             .collect(),
-        span: Span::test_data(),
-    }
+    );
+
+    Value::list(vec![record; row_cnt], Span::test_data())
 }
 
 fn encoding_benchmarks(c: &mut Criterion) {
     let mut group = c.benchmark_group("Encoding");
-    let test_cnt_pairs = [
-        (100, 5),
-        (100, 10),
-        (100, 15),
-        (1000, 5),
-        (1000, 10),
-        (1000, 15),
-        (10000, 5),
-        (10000, 10),
-        (10000, 15),
-    ];
+    let test_cnt_pairs = [(100, 5), (100, 15), (10000, 5), (10000, 15)];
     for (row_cnt, col_cnt) in test_cnt_pairs.into_iter() {
         for fmt in ["json", "msgpack"] {
             group.bench_function(&format!("{fmt} encode {row_cnt} * {col_cnt}"), |b| {
@@ -151,17 +160,7 @@ fn encoding_benchmarks(c: &mut Criterion) {
 
 fn decoding_benchmarks(c: &mut Criterion) {
     let mut group = c.benchmark_group("Decoding");
-    let test_cnt_pairs = [
-        (100, 5),
-        (100, 10),
-        (100, 15),
-        (1000, 5),
-        (1000, 10),
-        (1000, 15),
-        (10000, 5),
-        (10000, 10),
-        (10000, 15),
-    ];
+    let test_cnt_pairs = [(100, 5), (100, 15), (10000, 5), (10000, 15)];
     for (row_cnt, col_cnt) in test_cnt_pairs.into_iter() {
         for fmt in ["json", "msgpack"] {
             group.bench_function(&format!("{fmt} decode for {row_cnt} * {col_cnt}"), |b| {

codecov.yml

@@ -1,17 +0,0 @@
-coverage:
-  status:
-    project:
-      default:
-        target: 55%
-        threshold: 2%
-    patch:
-      default:
-        informational: true
-
-comment:
-  layout: reach, diff, files
-  behavior: default
-  require_base: yes
-  require_head: yes
-  after_n_builds: 1 # Disabled windows else: 2
-  

crates/nu-cli/Cargo.toml

@@ -5,38 +5,42 @@ repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cli"
 edition = "2021"
 license = "MIT"
 name = "nu-cli"
-version = "0.81.0"
+version = "0.88.2"
 
 [lib]
 bench = false
 
 [dev-dependencies]
-nu-test-support = { path = "../nu-test-support", version = "0.81.0" }
-rstest = { version = "0.17.0", default-features = false }
+nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.88.2" }
+nu-command = { path = "../nu-command", version = "0.88.2" }
+nu-test-support = { path = "../nu-test-support", version = "0.88.2" }
+rstest = { version = "0.18.1", default-features = false }
 
 [dependencies]
-nu-command = { path = "../nu-command", version = "0.81.0" }
-nu-engine = { path = "../nu-engine", version = "0.81.0" }
-nu-path = { path = "../nu-path", version = "0.81.0" }
-nu-parser = { path = "../nu-parser", version = "0.81.0" }
-nu-protocol = { path = "../nu-protocol", version = "0.81.0" }
-nu-utils = { path = "../nu-utils", version = "0.81.0" }
-nu-color-config = { path = "../nu-color-config", version = "0.81.0" }
-nu-ansi-term = "0.47.0"
-reedline = { version = "0.20.0", features = ["bashisms", "sqlite"]}
+nu-cmd-base = { path = "../nu-cmd-base", version = "0.88.2" }
+nu-engine = { path = "../nu-engine", version = "0.88.2" }
+nu-path = { path = "../nu-path", version = "0.88.2" }
+nu-parser = { path = "../nu-parser", version = "0.88.2" }
+nu-protocol = { path = "../nu-protocol", version = "0.88.2" }
+nu-utils = { path = "../nu-utils", version = "0.88.2" }
+nu-color-config = { path = "../nu-color-config", version = "0.88.2" }
+nu-ansi-term = "0.49.0"
+reedline = { version = "0.27.0", features = ["bashisms", "sqlite"] }
 
-atty = "0.2"
 chrono = { default-features = false, features = ["std"], version = "0.4" }
-crossterm = "0.26"
-fancy-regex = "0.11"
+crossterm = "0.27"
+fancy-regex = "0.12"
 fuzzy-matcher = "0.3"
 is_executable = "1.0"
 log = "0.4"
-miette = { version = "5.9", features = ["fancy-no-backtrace"] }
-once_cell = "1.17"
+miette = { version = "5.10", features = ["fancy-no-backtrace"] }
+once_cell = "1.18"
 percent-encoding = "2"
-sysinfo = "0.29"
+pathdiff = "0.2"
+sysinfo = "0.30"
 unicode-segmentation = "1.10"
+uuid = { version = "1.6.0", features = ["v4"] }
+which = "5.0.0"
 
 [features]
 plugin = []

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

@@ -1,9 +1,9 @@
 use nu_engine::CallExt;
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::Category;
-use nu_protocol::IntoPipelineData;
-use nu_protocol::{PipelineData, ShellError, Signature, SyntaxShape, Type, Value};
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
+};
 use unicode_segmentation::UnicodeSegmentation;
 
 #[derive(Clone)]
@@ -16,12 +16,20 @@ impl Command for Commandline {
 
     fn signature(&self) -> Signature {
         Signature::build("commandline")
-            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .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",
@@ -61,77 +69,60 @@ impl Command for Commandline {
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         if let Some(cmd) = call.opt::<Value>(engine_state, stack, 0)? {
-            let mut buffer = engine_state
-                .repl_buffer_state
-                .lock()
-                .expect("repl buffer state mutex");
-            let mut cursor_pos = engine_state
-                .repl_cursor_pos
-                .lock()
-                .expect("repl cursor pos mutex");
+            let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
 
             if call.has_flag("cursor") {
                 let cmd_str = cmd.as_string()?;
                 match cmd_str.parse::<i64>() {
                     Ok(n) => {
-                        *cursor_pos = if n <= 0 {
+                        repl.cursor_pos = if n <= 0 {
                             0usize
                         } else {
-                            buffer
+                            repl.buffer
                                 .grapheme_indices(true)
                                 .map(|(i, _c)| i)
                                 .nth(n as usize)
-                                .unwrap_or(buffer.len())
+                                .unwrap_or(repl.buffer.len())
                         }
                     }
                     Err(_) => {
                         return Err(ShellError::CantConvert {
                             to_type: "int".to_string(),
                             from_type: "string".to_string(),
-                            span: cmd.span()?,
+                            span: cmd.span(),
                             help: Some(format!(
-                                r#"string "{cmd_str}" does not represent a valid integer"#
+                                r#"string "{cmd_str}" does not represent a valid int"#
                             )),
                         })
                     }
                 }
             } else if call.has_flag("append") {
-                buffer.push_str(&cmd.as_string()?);
+                repl.buffer.push_str(&cmd.as_string()?);
             } else if call.has_flag("insert") {
                 let cmd_str = cmd.as_string()?;
-                buffer.insert_str(*cursor_pos, &cmd_str);
-                *cursor_pos += cmd_str.len();
+                let cursor_pos = repl.cursor_pos;
+                repl.buffer.insert_str(cursor_pos, &cmd_str);
+                repl.cursor_pos += cmd_str.len();
             } else {
-                *buffer = cmd.as_string()?;
-                *cursor_pos = buffer.len();
+                repl.buffer = cmd.as_string()?;
+                repl.cursor_pos = repl.buffer.len();
             }
-            Ok(Value::Nothing { span: call.head }.into_pipeline_data())
+            Ok(Value::nothing(call.head).into_pipeline_data())
         } else {
-            let buffer = engine_state
-                .repl_buffer_state
-                .lock()
-                .expect("repl buffer state mutex");
-            if call.has_flag("cursor") {
-                let cursor_pos = engine_state
-                    .repl_cursor_pos
-                    .lock()
-                    .expect("repl cursor pos mutex");
-                let char_pos = buffer
+            let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
+            if call.has_flag("cursor-end") {
+                repl.cursor_pos = repl.buffer.graphemes(true).count();
+                Ok(Value::nothing(call.head).into_pipeline_data())
+            } else if call.has_flag("cursor") {
+                let char_pos = repl
+                    .buffer
                     .grapheme_indices(true)
-                    .chain(std::iter::once((buffer.len(), "")))
-                    .position(|(i, _c)| i == *cursor_pos)
+                    .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 {
-                    val: char_pos.to_string(),
-                    span: call.head,
-                }
-                .into_pipeline_data())
+                Ok(Value::string(char_pos.to_string(), call.head).into_pipeline_data())
             } else {
-                Ok(Value::String {
-                    val: buffer.to_string(),
-                    span: call.head,
-                }
-                .into_pipeline_data())
+                Ok(Value::string(repl.buffer.to_string(), call.head).into_pipeline_data())
             }
         }
     }

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

@@ -26,7 +26,7 @@ pub fn add_cli_context(mut engine_state: EngineState) -> EngineState {
     };
 
     if let Err(err) = engine_state.merge_delta(delta) {
-        eprintln!("Error creating default context: {err:?}");
+        eprintln!("Error creating CLI command context: {err:?}");
     }
 
     engine_state

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

@@ -1,8 +1,8 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, HistoryFileFormat, IntoInterruptiblePipelineData, PipelineData, ShellError,
-    Signature, Span, Type, Value,
+    record, Category, Example, HistoryFileFormat, IntoInterruptiblePipelineData, PipelineData,
+    ShellError, Signature, Span, Type, Value,
 };
 use reedline::{
     FileBackedHistory, History as ReedlineHistory, HistoryItem, SearchDirection, SearchQuery,
@@ -34,7 +34,7 @@ impl Command for History {
                 "Show long listing of entries for sqlite history",
                 Some('l'),
             )
-            .category(Category::Misc)
+            .category(Category::History)
     }
 
     fn run(
@@ -70,12 +70,14 @@ impl Command for History {
             } else {
                 let history_reader: Option<Box<dyn ReedlineHistory>> =
                     match engine_state.config.history_file_format {
-                        HistoryFileFormat::Sqlite => SqliteBackedHistory::with_file(history_path)
-                            .map(|inner| {
-                                let boxed: Box<dyn ReedlineHistory> = Box::new(inner);
-                                boxed
-                            })
-                            .ok(),
+                        HistoryFileFormat::Sqlite => {
+                            SqliteBackedHistory::with_file(history_path, None, None)
+                                .map(|inner| {
+                                    let boxed: Box<dyn ReedlineHistory> = Box::new(inner);
+                                    boxed
+                                })
+                                .ok()
+                        }
 
                         HistoryFileFormat::PlainText => FileBackedHistory::with_file(
                             engine_state.config.max_history_size as usize,
@@ -95,22 +97,17 @@ impl Command for History {
                                 .ok()
                         })
                         .map(move |entries| {
-                            entries
-                                .into_iter()
-                                .enumerate()
-                                .map(move |(idx, entry)| Value::Record {
-                                    cols: vec!["command".to_string(), "index".to_string()],
-                                    vals: vec![
-                                        Value::String {
-                                            val: entry.command_line,
-                                            span: head,
-                                        },
-                                        Value::int(idx as i64, head),
-                                    ],
-                                    span: head,
-                                })
+                            entries.into_iter().enumerate().map(move |(idx, entry)| {
+                                Value::record(
+                                    record! {
+                                        "command" => Value::string(entry.command_line, head),
+                                        "index" => Value::int(idx as i64, head),
+                                    },
+                                    head,
+                                )
+                            })
                         })
-                        .ok_or(ShellError::FileNotFound(head))?
+                        .ok_or(ShellError::FileNotFound { span: head })?
                         .into_pipeline_data(ctrlc)),
                     HistoryFileFormat::Sqlite => Ok(history_reader
                         .and_then(|h| {
@@ -122,12 +119,12 @@ impl Command for History {
                                 create_history_record(idx, entry, long, head)
                             })
                         })
-                        .ok_or(ShellError::FileNotFound(head))?
+                        .ok_or(ShellError::FileNotFound { span: head })?
                         .into_pipeline_data(ctrlc)),
                 }
             }
         } else {
-            Err(ShellError::FileNotFound(head))
+            Err(ShellError::FileNotFound { span: head })
         }
     }
 
@@ -144,7 +141,7 @@ impl Command for History {
                 result: None,
             },
             Example {
-                example: "history | wrap cmd | where cmd =~ cargo",
+                example: "history | where command =~ cargo | get command",
                 description: "Search all the commands from history that contains 'cargo'",
                 result: None,
             },
@@ -156,8 +153,8 @@ fn create_history_record(idx: usize, entry: HistoryItem, long: bool, head: Span)
     //1. Format all the values
     //2. Create a record of either short or long columns and values
 
-    let item_id_value = Value::Int {
-        val: match entry.id {
+    let item_id_value = Value::int(
+        match entry.id {
             Some(id) => {
                 let ids = id.to_string();
                 match ids.parse::<i64>() {
@@ -167,21 +164,18 @@ fn create_history_record(idx: usize, entry: HistoryItem, long: bool, head: Span)
             }
             None => 0i64,
         },
-        span: head,
-    };
-    let start_timestamp_value = Value::String {
-        val: match entry.start_timestamp {
+        head,
+    );
+    let start_timestamp_value = Value::string(
+        match entry.start_timestamp {
             Some(time) => time.to_string(),
             None => "".into(),
         },
-        span: head,
-    };
-    let command_value = Value::String {
-        val: entry.command_line,
-        span: head,
-    };
-    let session_id_value = Value::Int {
-        val: match entry.session_id {
+        head,
+    );
+    let command_value = Value::string(entry.command_line, head);
+    let session_id_value = Value::int(
+        match entry.session_id {
             Some(sid) => {
                 let sids = sid.to_string();
                 match sids.parse::<i64>() {
@@ -191,74 +185,56 @@ fn create_history_record(idx: usize, entry: HistoryItem, long: bool, head: Span)
             }
             None => 0i64,
         },
-        span: head,
-    };
-    let hostname_value = Value::String {
-        val: match entry.hostname {
+        head,
+    );
+    let hostname_value = Value::string(
+        match entry.hostname {
             Some(host) => host,
             None => "".into(),
         },
-        span: head,
-    };
-    let cwd_value = Value::String {
-        val: match entry.cwd {
+        head,
+    );
+    let cwd_value = Value::string(
+        match entry.cwd {
             Some(cwd) => cwd,
             None => "".into(),
         },
-        span: head,
-    };
-    let duration_value = Value::Duration {
-        val: match entry.duration {
+        head,
+    );
+    let duration_value = Value::duration(
+        match entry.duration {
             Some(d) => d.as_nanos().try_into().unwrap_or(0),
             None => 0,
         },
-        span: head,
-    };
+        head,
+    );
     let exit_status_value = Value::int(entry.exit_status.unwrap_or(0), head);
     let index_value = Value::int(idx as i64, head);
     if long {
-        Value::Record {
-            cols: vec![
-                "item_id".into(),
-                "start_timestamp".into(),
-                "command".to_string(),
-                "session_id".into(),
-                "hostname".into(),
-                "cwd".into(),
-                "duration".into(),
-                "exit_status".into(),
-                "idx".to_string(),
-            ],
-            vals: vec![
-                item_id_value,
-                start_timestamp_value,
-                command_value,
-                session_id_value,
-                hostname_value,
-                cwd_value,
-                duration_value,
-                exit_status_value,
-                index_value,
-            ],
-            span: head,
-        }
+        Value::record(
+            record! {
+                "item_id" => item_id_value,
+                "start_timestamp" => start_timestamp_value,
+                "command" => command_value,
+                "session_id" => session_id_value,
+                "hostname" => hostname_value,
+                "cwd" => cwd_value,
+                "duration" => duration_value,
+                "exit_status" => exit_status_value,
+                "idx" => index_value,
+            },
+            head,
+        )
     } else {
-        Value::Record {
-            cols: vec![
-                "start_timestamp".into(),
-                "command".to_string(),
-                "cwd".into(),
-                "duration".into(),
-                "exit_status".into(),
-            ],
-            vals: vec![
-                start_timestamp_value,
-                command_value,
-                cwd_value,
-                duration_value,
-                exit_status_value,
-            ],
-            span: head,
-        }
+        Value::record(
+            record! {
+                "start_timestamp" => start_timestamp_value,
+                "command" => command_value,
+                "cwd" => cwd_value,
+                "duration" => duration_value,
+                "exit_status" => exit_status_value,
+            },
+            head,
+        )
     }
 }

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

@@ -18,7 +18,7 @@ impl Command for HistorySession {
 
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("history session")
-            .category(Category::Misc)
+            .category(Category::History)
             .input_output_types(vec![(Type::Nothing, Type::Int)])
     }
 

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

@@ -0,0 +1,5 @@
+mod history_;
+mod history_session;
+
+pub use history_::History;
+pub use history_session::HistorySession;

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

@@ -24,7 +24,10 @@ impl Command for Keybindings {
     }
 
     fn extra_usage(&self) -> &str {
-        "You must use one of the following subcommands. Using this command as-is will only produce this help message."
+        r#"You must use one of the following subcommands. Using this command as-is will only produce this help message.
+
+For more information on input and keybindings, check:
+  https://www.nushell.sh/book/line_editor.html"#
     }
 
     fn search_terms(&self) -> Vec<&str> {
@@ -38,16 +41,16 @@ impl Command for Keybindings {
         call: &Call,
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        Ok(Value::String {
-            val: get_full_help(
+        Ok(Value::string(
+            get_full_help(
                 &Keybindings.signature(),
                 &Keybindings.examples(),
                 engine_state,
                 stack,
                 self.is_parser_keyword(),
             ),
-            span: call.head,
-        }
+            call.head,
+        )
         .into_pipeline_data())
     }
 }

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

@@ -1,7 +1,7 @@
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Type, Value,
+    record, Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Type, Value,
 };
 use reedline::get_reedline_default_keybindings;
 
@@ -41,43 +41,18 @@ impl Command for KeybindingsDefault {
         let records = get_reedline_default_keybindings()
             .into_iter()
             .map(|(mode, modifier, code, event)| {
-                let mode = Value::String {
-                    val: mode,
-                    span: call.head,
-                };
-
-                let modifier = Value::String {
-                    val: modifier,
-                    span: call.head,
-                };
-
-                let code = Value::String {
-                    val: code,
-                    span: call.head,
-                };
-
-                let event = Value::String {
-                    val: event,
-                    span: call.head,
-                };
-
-                Value::Record {
-                    cols: vec![
-                        "mode".to_string(),
-                        "modifier".to_string(),
-                        "code".to_string(),
-                        "event".to_string(),
-                    ],
-                    vals: vec![mode, modifier, code, event],
-                    span: call.head,
-                }
+                Value::record(
+                    record! {
+                        "mode" => Value::string(mode, call.head),
+                        "modifier" => Value::string(modifier, call.head),
+                        "code" => Value::string(code, call.head),
+                        "event" => Value::string(event, call.head),
+                    },
+                    call.head,
+                )
             })
             .collect();
 
-        Ok(Value::List {
-            vals: records,
-            span: call.head,
-        }
-        .into_pipeline_data())
+        Ok(Value::list(records, call.head).into_pipeline_data())
     }
 }

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

@@ -1,7 +1,8 @@
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Type, Value,
+    record, Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Type,
+    Value,
 };
 use reedline::{
     get_reedline_edit_commands, get_reedline_keybinding_modifiers, get_reedline_keycodes,
@@ -35,7 +36,7 @@ impl Command for KeybindingsList {
         vec![
             Example {
                 description: "Get list of key modifiers",
-                example: "keybindings list -m",
+                example: "keybindings list --modifiers",
                 result: None,
             },
             Example {
@@ -59,26 +60,22 @@ impl Command for KeybindingsList {
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let records = if call.named_len() == 0 {
-            let all_options = vec!["modifiers", "keycodes", "edits", "modes", "events"];
+            let all_options = ["modifiers", "keycodes", "edits", "modes", "events"];
             all_options
                 .iter()
-                .flat_map(|argument| get_records(argument, &call.head))
+                .flat_map(|argument| get_records(argument, call.head))
                 .collect()
         } else {
             call.named_iter()
-                .flat_map(|(argument, _, _)| get_records(argument.item.as_str(), &call.head))
+                .flat_map(|(argument, _, _)| get_records(argument.item.as_str(), call.head))
                 .collect()
         };
 
-        Ok(Value::List {
-            vals: records,
-            span: call.head,
-        }
-        .into_pipeline_data())
+        Ok(Value::list(records, call.head).into_pipeline_data())
     }
 }
 
-fn get_records(entry_type: &str, span: &Span) -> Vec<Value> {
+fn get_records(entry_type: &str, span: Span) -> Vec<Value> {
     let values = match entry_type {
         "modifiers" => get_reedline_keybinding_modifiers().sorted(),
         "keycodes" => get_reedline_keycodes().sorted(),
@@ -95,16 +92,14 @@ fn get_records(entry_type: &str, span: &Span) -> Vec<Value> {
         .collect()
 }
 
-fn convert_to_record(edit: &str, entry_type: &str, span: &Span) -> Value {
-    let entry_type = Value::string(entry_type, *span);
-
-    let name = Value::string(edit, *span);
-
-    Value::Record {
-        cols: vec!["type".to_string(), "name".to_string()],
-        vals: vec![entry_type, name],
-        span: *span,
-    }
+fn convert_to_record(edit: &str, entry_type: &str, span: Span) -> Value {
+    Value::record(
+        record! {
+            "type" => Value::string(entry_type, span),
+            "name" => Value::string(edit, span),
+        },
+        span,
+    )
 }
 
 // Helper to sort a vec and return a vec

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

@@ -1,9 +1,11 @@
+use crossterm::execute;
 use crossterm::QueueableCommand;
 use crossterm::{event::Event, event::KeyCode, event::KeyEvent, terminal};
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Type, Value,
+    record, Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Type,
+    Value,
 };
 use std::io::{stdout, Write};
 
@@ -19,6 +21,10 @@ impl Command for KeybindingsListen {
         "Get input from the user."
     }
 
+    fn extra_usage(&self) -> &str {
+        "This is an internal debugging tool. For better output, try `input listen --types [key]`"
+    }
+
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .category(Category::Platform)
@@ -39,13 +45,13 @@ impl Command for KeybindingsListen {
             Ok(v) => Ok(v.into_pipeline_data()),
             Err(e) => {
                 terminal::disable_raw_mode()?;
-                Err(ShellError::GenericError(
-                    "Error with input".to_string(),
-                    "".to_string(),
-                    None,
-                    Some(e.to_string()),
-                    Vec::new(),
-                ))
+                Err(ShellError::GenericError {
+                    error: "Error with input".into(),
+                    msg: "".into(),
+                    span: None,
+                    help: Some(e.to_string()),
+                    inner: vec![],
+                })
             }
         }
     }
@@ -64,6 +70,32 @@ pub fn print_events(engine_state: &EngineState) -> Result<Value, ShellError> {
 
     stdout().flush()?;
     terminal::enable_raw_mode()?;
+
+    if config.use_kitty_protocol {
+        if let Ok(false) = crossterm::terminal::supports_keyboard_enhancement() {
+            println!("WARN: The terminal doesn't support use_kitty_protocol config.\r");
+        }
+
+        // enable kitty protocol
+        //
+        // Note that, currently, only the following support this protocol:
+        // * [kitty terminal](https://sw.kovidgoyal.net/kitty/)
+        // * [foot terminal](https://codeberg.org/dnkl/foot/issues/319)
+        // * [WezTerm terminal](https://wezfurlong.org/wezterm/config/lua/config/enable_kitty_keyboard.html)
+        // * [notcurses library](https://github.com/dankamongmen/notcurses/issues/2131)
+        // * [neovim text editor](https://github.com/neovim/neovim/pull/18181)
+        // * [kakoune text editor](https://github.com/mawww/kakoune/issues/4103)
+        // * [dte text editor](https://gitlab.com/craigbarnes/dte/-/issues/138)
+        //
+        // Refer to https://sw.kovidgoyal.net/kitty/keyboard-protocol/ if you're curious.
+        let _ = execute!(
+            stdout(),
+            crossterm::event::PushKeyboardEnhancementFlags(
+                crossterm::event::KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
+            )
+        );
+    }
+
     let mut stdout = std::io::BufWriter::new(std::io::stderr());
 
     loop {
@@ -78,9 +110,8 @@ pub fn print_events(engine_state: &EngineState) -> Result<Value, ShellError> {
         let v = print_events_helper(event)?;
         // Print out the record
         let o = match v {
-            Value::Record { cols, vals, .. } => cols
+            Value::Record { val, .. } => val
                 .iter()
-                .zip(vals.iter())
                 .map(|(x, y)| format!("{}: {}", x, y.into_string("", config)))
                 .collect::<Vec<String>>()
                 .join(", "),
@@ -91,6 +122,14 @@ pub fn print_events(engine_state: &EngineState) -> Result<Value, ShellError> {
         stdout.queue(crossterm::style::Print("\r\n"))?;
         stdout.flush()?;
     }
+
+    if config.use_kitty_protocol {
+        let _ = execute!(
+            std::io::stdout(),
+            crossterm::event::PopKeyboardEnhancementFlags
+        );
+    }
+
     terminal::disable_raw_mode()?;
 
     Ok(Value::nothing(Span::unknown()))
@@ -111,46 +150,29 @@ fn print_events_helper(event: Event) -> Result<Value, ShellError> {
     {
         match code {
             KeyCode::Char(c) => {
-                let record = Value::Record {
-                    cols: vec![
-                        "char".into(),
-                        "code".into(),
-                        "modifier".into(),
-                        "flags".into(),
-                        "kind".into(),
-                        "state".into(),
-                    ],
-                    vals: vec![
-                        Value::string(format!("{c}"), Span::unknown()),
-                        Value::string(format!("{:#08x}", u32::from(c)), Span::unknown()),
-                        Value::string(format!("{modifiers:?}"), Span::unknown()),
-                        Value::string(format!("{modifiers:#08b}"), Span::unknown()),
-                        Value::string(format!("{kind:?}"), Span::unknown()),
-                        Value::string(format!("{state:?}"), Span::unknown()),
-                    ],
-                    span: Span::unknown(),
+                let record = record! {
+                    "char" => Value::string(format!("{c}"), Span::unknown()),
+                    "code" => Value::string(format!("{:#08x}", u32::from(c)), Span::unknown()),
+                    "modifier" => Value::string(format!("{modifiers:?}"), Span::unknown()),
+                    "flags" => Value::string(format!("{modifiers:#08b}"), Span::unknown()),
+                    "kind" => Value::string(format!("{kind:?}"), Span::unknown()),
+                    "state" => Value::string(format!("{state:?}"), Span::unknown()),
                 };
-                Ok(record)
+                Ok(Value::record(record, Span::unknown()))
             }
             _ => {
-                let record = Value::Record {
-                    cols: vec!["code".into(), "modifier".into(), "flags".into()],
-                    vals: vec![
-                        Value::string(format!("{code:?}"), Span::unknown()),
-                        Value::string(format!("{modifiers:?}"), Span::unknown()),
-                        Value::string(format!("{modifiers:#08b}"), Span::unknown()),
-                    ],
-                    span: Span::unknown(),
+                let record = record! {
+                    "code" => Value::string(format!("{code:?}"), Span::unknown()),
+                    "modifier" => Value::string(format!("{modifiers:?}"), Span::unknown()),
+                    "flags" => Value::string(format!("{modifiers:#08b}"), Span::unknown()),
+                    "kind" => Value::string(format!("{kind:?}"), Span::unknown()),
+                    "state" => Value::string(format!("{state:?}"), Span::unknown()),
                 };
-                Ok(record)
+                Ok(Value::record(record, Span::unknown()))
             }
         }
     } else {
-        let record = Value::Record {
-            cols: vec!["event".into()],
-            vals: vec![Value::string(format!("{event:?}"), Span::unknown())],
-            span: Span::unknown(),
-        };
-        Ok(record)
+        let record = record! { "event" => Value::string(format!("{event:?}"), Span::unknown()) };
+        Ok(Value::record(record, Span::unknown()))
     }
 }

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

@@ -1,15 +1,13 @@
 mod commandline;
 mod default_context;
 mod history;
-mod history_session;
 mod keybindings;
 mod keybindings_default;
 mod keybindings_list;
 mod keybindings_listen;
 
 pub use commandline::Commandline;
-pub use history::History;
-pub use history_session::HistorySession;
+pub use history::{History, HistorySession};
 pub use keybindings::Keybindings;
 pub use keybindings_default::KeybindingsDefault;
 pub use keybindings_list::KeybindingsList;

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

@@ -89,7 +89,7 @@ impl CommandCompletion {
         let filter_predicate = |command: &[u8]| match_algorithm.matches_u8(command, partial);
 
         let mut results = working_set
-            .find_commands_by_predicate(filter_predicate)
+            .find_commands_by_predicate(filter_predicate, true)
             .into_iter()
             .map(move |x| Suggestion {
                 value: String::from_utf8_lossy(&x.0).to_string(),
@@ -205,10 +205,7 @@ impl Completer for CommandCompletion {
             vec![]
         };
 
-        subcommands
-            .into_iter()
-            .chain(commands.into_iter())
-            .collect::<Vec<_>>()
+        subcommands.into_iter().chain(commands).collect::<Vec<_>>()
     }
 
     fn get_sort_by(&self) -> SortBy {
@@ -237,7 +234,7 @@ pub fn is_passthrough_command(working_set_file_contents: &[(Vec<u8>, usize, usiz
         let cur_pos = find_non_whitespace_index(contents, last_pipe_pos);
 
         let result = match contents.get(cur_pos..) {
-            Some(contents) => contents.starts_with(b"sudo "),
+            Some(contents) => contents.starts_with(b"sudo ") || contents.starts_with(b"doas "),
             None => false,
         };
         if result {
@@ -266,7 +263,7 @@ mod command_completions_tests {
             ("	hello sud", 1),
         ];
         for (idx, ele) in commands.iter().enumerate() {
-            let index = find_non_whitespace_index(&Vec::from(ele.0.as_bytes()), 0);
+            let index = find_non_whitespace_index(ele.0.as_bytes(), 0);
             assert_eq!(index, ele.1, "Failed on index {}", idx);
         }
     }

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

@@ -1,6 +1,6 @@
 use crate::completions::{
     CommandCompletion, Completer, CompletionOptions, CustomCompletion, DirectoryCompletion,
-    DotNuCompletion, FileCompletion, FlagCompletion, MatchAlgorithm, VariableCompletion,
+    DotNuCompletion, FileCompletion, FlagCompletion, VariableCompletion,
 };
 use nu_engine::eval_block;
 use nu_parser::{flatten_expression, parse, FlatShape};
@@ -39,15 +39,12 @@ impl NuCompleter {
     ) -> Vec<Suggestion> {
         let config = self.engine_state.get_config();
 
-        let mut options = CompletionOptions {
+        let options = CompletionOptions {
             case_sensitive: config.case_sensitive_completions,
+            match_algorithm: config.completion_algorithm.into(),
             ..Default::default()
         };
 
-        if config.completion_algorithm == "fuzzy" {
-            options.match_algorithm = MatchAlgorithm::Fuzzy;
-        }
-
         // Fetch
         let mut suggestions =
             completer.fetch(working_set, prefix.clone(), new_span, offset, pos, &options);
@@ -67,20 +64,20 @@ impl NuCompleter {
     ) -> Option<Vec<Suggestion>> {
         let stack = self.stack.clone();
         let block = self.engine_state.get_block(block_id);
-        let mut callee_stack = stack.gather_captures(&block.captures);
+        let mut callee_stack = stack.gather_captures(&self.engine_state, &block.captures);
 
         // Line
-        if let Some(pos_arg) = block.signature.required_positional.get(0) {
+        if let Some(pos_arg) = block.signature.required_positional.first() {
             if let Some(var_id) = pos_arg.var_id {
                 callee_stack.add_var(
                     var_id,
-                    Value::List {
-                        vals: spans
+                    Value::list(
+                        spans
                             .iter()
                             .map(|it| Value::string(it, Span::unknown()))
                             .collect(),
-                        span: Span::unknown(),
-                    },
+                        Span::unknown(),
+                    ),
                 );
             }
         }
@@ -97,7 +94,7 @@ impl NuCompleter {
         match result {
             Ok(pd) => {
                 let value = pd.into_value(span);
-                if let Value::List { vals, span: _ } = value {
+                if let Value::List { vals, .. } = value {
                     let result =
                         map_value_completions(vals.iter(), Span::new(span.start, span.end), offset);
 
@@ -125,35 +122,45 @@ impl NuCompleter {
             for pipeline_element in pipeline.elements {
                 match pipeline_element {
                     PipelineElement::Expression(_, expr)
-                    | PipelineElement::Redirection(_, _, expr)
+                    | PipelineElement::Redirection(_, _, expr, _)
                     | PipelineElement::And(_, expr)
                     | PipelineElement::Or(_, expr)
                     | PipelineElement::SameTargetRedirection { cmd: (_, expr), .. }
-                    | PipelineElement::SeparateRedirection { out: (_, expr), .. } => {
+                    | PipelineElement::SeparateRedirection {
+                        out: (_, expr, _), ..
+                    } => {
                         let flattened: Vec<_> = flatten_expression(&working_set, &expr);
                         let mut spans: Vec<String> = vec![];
 
                         for (flat_idx, flat) in flattened.iter().enumerate() {
                             let is_passthrough_command = spans
                                 .first()
-                                .filter(|content| *content == &String::from("sudo"))
+                                .filter(|content| {
+                                    content.as_str() == "sudo" || content.as_str() == "doas"
+                                })
                                 .is_some();
                             // Read the current spam to string
                             let current_span = working_set.get_span_contents(flat.0).to_vec();
                             let current_span_str = String::from_utf8_lossy(&current_span);
 
+                            let is_last_span = pos >= flat.0.start && pos < flat.0.end;
+
                             // Skip the last 'a' as span item
-                            if flat_idx == flattened.len() - 1 {
-                                let mut chars = current_span_str.chars();
-                                chars.next_back();
-                                let current_span_str = chars.as_str().to_owned();
-                                spans.push(current_span_str.to_string());
+                            if is_last_span {
+                                let offset = pos - flat.0.start;
+                                if offset == 0 {
+                                    spans.push(String::new())
+                                } else {
+                                    let mut current_span_str = current_span_str.to_string();
+                                    current_span_str.remove(offset);
+                                    spans.push(current_span_str);
+                                }
                             } else {
                                 spans.push(current_span_str.to_string());
                             }
 
                             // Complete based on the last span
-                            if pos >= flat.0.start && pos < flat.0.end {
+                            if is_last_span {
                                 // Context variables
                                 let most_left_var =
                                     most_left_variable(flat_idx, &working_set, flattened.clone());
@@ -243,7 +250,9 @@ impl NuCompleter {
                                             working_set.get_span_contents(previous_expr.0).to_vec();
 
                                         // Completion for .nu files
-                                        if prev_expr_str == b"use" || prev_expr_str == b"source-env"
+                                        if prev_expr_str == b"use"
+                                            || prev_expr_str == b"overlay use"
+                                            || prev_expr_str == b"source-env"
                                         {
                                             let mut completer =
                                                 DotNuCompletion::new(self.engine_state.clone());
@@ -454,7 +463,7 @@ pub fn map_value_completions<'a>(
         }
 
         // Match for record values
-        if let Ok((cols, vals)) = x.as_record() {
+        if let Ok(record) = x.as_record() {
             let mut suggestion = Suggestion {
                 value: String::from(""), // Initialize with empty string
                 description: None,
@@ -467,7 +476,7 @@ pub fn map_value_completions<'a>(
             };
 
             // Iterate the cols looking for `value` and `description`
-            cols.iter().zip(vals).for_each(|it| {
+            record.iter().for_each(|it| {
                 // Match `value` column
                 if it.0 == "value" {
                     // Convert the value to string
@@ -501,7 +510,8 @@ mod completer_tests {
 
     #[test]
     fn test_completion_helper() {
-        let mut engine_state = nu_command::create_default_context();
+        let mut engine_state =
+            nu_command::add_shell_command_context(nu_cmd_lang::create_default_context());
 
         // Custom additions
         let delta = {

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

@@ -0,0 +1,199 @@
+use crate::completions::{matches, CompletionOptions};
+use nu_path::home_dir;
+use nu_protocol::{engine::StateWorkingSet, Span};
+use std::path::{is_separator, Component, Path, PathBuf, MAIN_SEPARATOR as SEP};
+
+fn complete_rec(
+    partial: &[String],
+    cwd: &Path,
+    options: &CompletionOptions,
+    dir: bool,
+    isdir: bool,
+) -> Vec<PathBuf> {
+    let mut completions = vec![];
+
+    if let Ok(result) = cwd.read_dir() {
+        for entry in result.filter_map(|e| e.ok()) {
+            let entry_name = entry.file_name().to_string_lossy().into_owned();
+            let path = entry.path();
+
+            if !dir || path.is_dir() {
+                match partial.first() {
+                    Some(base) if matches(base, &entry_name, options) => {
+                        let partial = &partial[1..];
+                        if !partial.is_empty() || isdir {
+                            completions.extend(complete_rec(partial, &path, options, dir, isdir));
+                            if entry_name.eq(base) {
+                                break;
+                            }
+                        } else {
+                            completions.push(path)
+                        }
+                    }
+                    None => completions.push(path),
+                    _ => {}
+                }
+            }
+        }
+    }
+    completions
+}
+
+enum OriginalCwd {
+    None,
+    Home(PathBuf),
+    Some(PathBuf),
+    // referencing a single local file
+    Local(PathBuf),
+}
+
+impl OriginalCwd {
+    fn apply(&self, p: &Path) -> String {
+        let mut ret = match self {
+            Self::None => p.to_string_lossy().into_owned(),
+            Self::Some(base) => pathdiff::diff_paths(p, base)
+                .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(),
+        };
+
+        if p.is_dir() {
+            ret.push(SEP);
+        }
+        ret
+    }
+}
+
+fn surround_remove(partial: &str) -> String {
+    for c in ['`', '"', '\''] {
+        if partial.starts_with(c) {
+            let ret = partial.strip_prefix(c).unwrap_or(partial);
+            return match ret.split(c).collect::<Vec<_>>()[..] {
+                [inside] => inside.to_string(),
+                [inside, outside] if inside.ends_with(is_separator) => format!("{inside}{outside}"),
+                _ => ret.to_string(),
+            };
+        }
+    }
+    partial.to_string()
+}
+
+pub fn complete_item(
+    want_directory: bool,
+    span: nu_protocol::Span,
+    partial: &str,
+    cwd: &str,
+    options: &CompletionOptions,
+) -> Vec<(nu_protocol::Span, String)> {
+    let partial = surround_remove(partial);
+    let isdir = partial.ends_with(is_separator);
+    let cwd_pathbuf = Path::new(cwd).to_path_buf();
+    let mut original_cwd = OriginalCwd::None;
+    let mut components = Path::new(&partial).components().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();
+            };
+            [c, Component::RootDir].iter().collect()
+        }
+        Some(c @ Component::RootDir) => {
+            components.next();
+            PathBuf::from(c.as_os_str())
+        }
+        Some(Component::Normal(home)) if home.to_string_lossy() == "~" => {
+            components.next();
+            original_cwd = OriginalCwd::Home(home_dir().unwrap_or(cwd_pathbuf.clone()));
+            home_dir().unwrap_or(cwd_pathbuf)
+        }
+        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 mut partial = vec![];
+
+    for component in components {
+        match component {
+            Component::Prefix(..) => unreachable!(),
+            Component::RootDir => unreachable!(),
+            Component::CurDir => {}
+            Component::ParentDir => {
+                if partial.pop().is_none() {
+                    cwd.pop();
+                }
+            }
+            Component::Normal(c) => partial.push(c.to_string_lossy().into_owned()),
+        }
+    }
+
+    complete_rec(partial.as_slice(), &cwd, options, want_directory, isdir)
+        .into_iter()
+        .map(|p| (span, escape_path(original_cwd.apply(&p), want_directory)))
+        .collect()
+}
+
+// Fix files or folders with quotes or hashes
+pub fn escape_path(path: String, dir: bool) -> String {
+    let filename_contaminated = !dir && path.contains(['\'', '"', ' ', '#', '(', ')']);
+    let dirname_contaminated = dir && path.contains(['\'', '"', ' ', '#']);
+    let maybe_flag = path.starts_with('-');
+    let maybe_number = path.parse::<f64>().is_ok();
+    if filename_contaminated || dirname_contaminated || maybe_flag || maybe_number {
+        format!("`{path}`")
+    } else {
+        path
+    }
+}
+
+pub struct AdjustView {
+    pub prefix: String,
+    pub span: Span,
+    pub readjusted: bool,
+}
+
+pub fn adjust_if_intermediate(
+    prefix: &[u8],
+    working_set: &StateWorkingSet,
+    mut span: nu_protocol::Span,
+) -> AdjustView {
+    let span_contents = String::from_utf8_lossy(working_set.get_span_contents(span)).to_string();
+    let mut prefix = String::from_utf8_lossy(prefix).to_string();
+
+    // A difference of 1 because of the cursor's unicode code point in between.
+    // Using .chars().count() because unicode and Windows.
+    let readjusted = span_contents.chars().count() - prefix.chars().count() > 1;
+    if readjusted {
+        let remnant: String = span_contents
+            .chars()
+            .skip(prefix.chars().count() + 1)
+            .take_while(|&c| !is_separator(c))
+            .collect();
+        prefix.push_str(&remnant);
+        span = Span::new(span.start, span.start + prefix.chars().count() + 1);
+    }
+    AdjustView {
+        prefix,
+        span,
+        readjusted,
+    }
+}

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

@@ -2,6 +2,7 @@ use std::fmt::Display;
 
 use fuzzy_matcher::{skim::SkimMatcherV2, FuzzyMatcher};
 use nu_parser::trim_quotes_str;
+use nu_protocol::CompletionAlgorithm;
 
 #[derive(Copy, Clone)]
 pub enum SortBy {
@@ -55,6 +56,15 @@ impl MatchAlgorithm {
     }
 }
 
+impl From<CompletionAlgorithm> for MatchAlgorithm {
+    fn from(value: CompletionAlgorithm) -> Self {
+        match value {
+            CompletionAlgorithm::Prefix => MatchAlgorithm::Prefix,
+            CompletionAlgorithm::Fuzzy => MatchAlgorithm::Fuzzy,
+        }
+    }
+}
+
 impl TryFrom<String> for MatchAlgorithm {
     type Error = InvalidMatchAlgorithm;
 

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

@@ -5,8 +5,10 @@ use nu_protocol::{
     engine::{EngineState, Stack, StateWorkingSet},
     PipelineData, Span, Type, Value,
 };
+use nu_utils::IgnoreCaseExt;
 use reedline::Suggestion;
-use std::{collections::HashMap, sync::Arc};
+use std::collections::HashMap;
+use std::sync::Arc;
 
 use super::completer::map_value_completions;
 
@@ -78,21 +80,20 @@ impl Completer for CustomCompletion {
             .map(|pd| {
                 let value = pd.into_value(span);
                 match &value {
-                    Value::Record { .. } => {
-                        let completions = value
-                            .get_data_by_key("completions")
+                    Value::Record { val, .. } => {
+                        let completions = val
+                            .get("completions")
                             .and_then(|val| {
                                 val.as_list()
                                     .ok()
                                     .map(|it| map_value_completions(it.iter(), span, offset))
                             })
                             .unwrap_or_default();
-                        let options = value.get_data_by_key("options");
+                        let options = val.get("options");
 
-                        if let Some(Value::Record { .. }) = &options {
-                            let options = options.unwrap_or_default();
+                        if let Some(Value::Record { val: options, .. }) = &options {
                             let should_sort = options
-                                .get_data_by_key("sort")
+                                .get("sort")
                                 .and_then(|val| val.as_bool().ok())
                                 .unwrap_or(false);
 
@@ -102,11 +103,11 @@ impl Completer for CustomCompletion {
 
                             custom_completion_options = Some(CompletionOptions {
                                 case_sensitive: options
-                                    .get_data_by_key("case_sensitive")
+                                    .get("case_sensitive")
                                     .and_then(|val| val.as_bool().ok())
                                     .unwrap_or(true),
                                 positional: options
-                                    .get_data_by_key("positional")
+                                    .get("positional")
                                     .and_then(|val| val.as_bool().ok())
                                     .unwrap_or(true),
                                 sort_by: if should_sort {
@@ -114,9 +115,7 @@ impl Completer for CustomCompletion {
                                 } else {
                                     SortBy::None
                                 },
-                                match_algorithm: match options
-                                    .get_data_by_key("completion_algorithm")
-                                {
+                                match_algorithm: match options.get("completion_algorithm") {
                                     Some(option) => option
                                         .as_string()
                                         .ok()
@@ -155,8 +154,8 @@ fn filter(prefix: &[u8], items: Vec<Suggestion>, options: &CompletionOptions) ->
                 (true, true) => it.value.as_bytes().starts_with(prefix),
                 (true, false) => it.value.contains(std::str::from_utf8(prefix).unwrap_or("")),
                 (false, positional) => {
-                    let value = it.value.to_lowercase();
-                    let prefix = std::str::from_utf8(prefix).unwrap_or("").to_lowercase();
+                    let value = it.value.to_folded_case();
+                    let prefix = std::str::from_utf8(prefix).unwrap_or("").to_folded_case();
                     if positional {
                         value.starts_with(&prefix)
                     } else {

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

@@ -1,17 +1,15 @@
-use crate::completions::{matches, Completer, CompletionOptions};
+use crate::completions::{
+    completion_common::{adjust_if_intermediate, complete_item, AdjustView},
+    Completer, CompletionOptions, SortBy,
+};
 use nu_protocol::{
     engine::{EngineState, StateWorkingSet},
     levenshtein_distance, Span,
 };
 use reedline::Suggestion;
-use std::fs;
-use std::path::Path;
+use std::path::{Path, MAIN_SEPARATOR as SEP};
 use std::sync::Arc;
 
-use super::{partial_from, prepend_base_dir, SortBy};
-
-const SEP: char = std::path::MAIN_SEPARATOR;
-
 #[derive(Clone)]
 pub struct DirectoryCompletion {
     engine_state: Arc<EngineState>,
@@ -26,30 +24,34 @@ impl DirectoryCompletion {
 impl Completer for DirectoryCompletion {
     fn fetch(
         &mut self,
-        _: &StateWorkingSet,
+        working_set: &StateWorkingSet,
         prefix: Vec<u8>,
         span: Span,
         offset: usize,
         _: usize,
         options: &CompletionOptions,
     ) -> Vec<Suggestion> {
-        let cwd = self.engine_state.current_work_dir();
-        let partial = String::from_utf8_lossy(&prefix).to_string();
+        let AdjustView { prefix, span, .. } = adjust_if_intermediate(&prefix, working_set, span);
 
         // Filter only the folders
-        let output: Vec<_> = directory_completion(span, &partial, &cwd, options)
-            .into_iter()
-            .map(move |x| Suggestion {
-                value: x.1,
-                description: None,
-                extra: None,
-                span: reedline::Span {
-                    start: x.0.start - offset,
-                    end: x.0.end - offset,
-                },
-                append_whitespace: false,
-            })
-            .collect();
+        let output: Vec<_> = directory_completion(
+            span,
+            &prefix,
+            &self.engine_state.current_work_dir(),
+            options,
+        )
+        .into_iter()
+        .map(move |x| Suggestion {
+            value: x.1,
+            description: None,
+            extra: None,
+            span: reedline::Span {
+                start: x.0.start - offset,
+                end: x.0.end - offset,
+            },
+            append_whitespace: false,
+        })
+        .collect();
 
         output
     }
@@ -63,7 +65,12 @@ impl Completer for DirectoryCompletion {
 
         match self.get_sort_by() {
             SortBy::Ascending => {
-                sorted_items.sort_by(|a, b| a.value.cmp(&b.value));
+                sorted_items.sort_by(|a, b| {
+                    // Ignore trailing slashes in folder names when sorting
+                    a.value
+                        .trim_end_matches(SEP)
+                        .cmp(b.value.trim_end_matches(SEP))
+                });
             }
             SortBy::LevenshteinDistance => {
                 sorted_items.sort_by(|a, b| {
@@ -106,60 +113,5 @@ pub fn directory_completion(
     cwd: &str,
     options: &CompletionOptions,
 ) -> Vec<(nu_protocol::Span, String)> {
-    let original_input = partial;
-
-    let (base_dir_name, partial) = partial_from(partial);
-
-    let base_dir = nu_path::expand_path_with(&base_dir_name, cwd);
-
-    // This check is here as base_dir.read_dir() with base_dir == "" will open the current dir
-    // which we don't want in this case (if we did, base_dir would already be ".")
-    if base_dir == Path::new("") {
-        return Vec::new();
-    }
-
-    if let Ok(result) = base_dir.read_dir() {
-        return result
-            .filter_map(|entry| {
-                entry.ok().and_then(|entry| {
-                    if let Ok(metadata) = fs::metadata(entry.path()) {
-                        if metadata.is_dir() {
-                            let mut file_name = entry.file_name().to_string_lossy().into_owned();
-                            if matches(&partial, &file_name, options) {
-                                let mut path = if prepend_base_dir(original_input, &base_dir_name) {
-                                    format!("{base_dir_name}{file_name}")
-                                } else {
-                                    file_name.to_string()
-                                };
-
-                                if entry.path().is_dir() {
-                                    path.push(SEP);
-                                    file_name.push(SEP);
-                                }
-
-                                // Fix files or folders with quotes or hash
-                                if path.contains('\'')
-                                    || path.contains('"')
-                                    || path.contains(' ')
-                                    || path.contains('#')
-                                {
-                                    path = format!("`{path}`");
-                                }
-
-                                Some((span, path))
-                            } else {
-                                None
-                            }
-                        } else {
-                            None
-                        }
-                    } else {
-                        None
-                    }
-                })
-            })
-            .collect();
-    }
-
-    Vec::new()
+    complete_item(true, span, partial, cwd, options)
 }

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

@@ -1,13 +1,13 @@
-use crate::completions::{
-    file_path_completion, partial_from, Completer, CompletionOptions, SortBy,
-};
+use crate::completions::{file_path_completion, Completer, CompletionOptions, SortBy};
 use nu_protocol::{
     engine::{EngineState, StateWorkingSet},
     Span,
 };
 use reedline::Suggestion;
-use std::sync::Arc;
-const SEP: char = std::path::MAIN_SEPARATOR;
+use std::{
+    path::{is_separator, Path, MAIN_SEPARATOR as SEP, MAIN_SEPARATOR_STR},
+    sync::Arc,
+};
 
 #[derive(Clone)]
 pub struct DotNuCompletion {
@@ -30,9 +30,16 @@ impl Completer for DotNuCompletion {
         _: usize,
         options: &CompletionOptions,
     ) -> Vec<Suggestion> {
-        let prefix_str = String::from_utf8_lossy(&prefix).to_string();
+        let prefix_str = String::from_utf8_lossy(&prefix).replace('`', "");
         let mut search_dirs: Vec<String> = vec![];
-        let (base_dir, mut partial) = partial_from(&prefix_str);
+
+        // If prefix_str is only a word we want to search in the current dir
+        let (base, partial) = prefix_str
+            .rsplit_once(is_separator)
+            .unwrap_or((".", &prefix_str));
+        let base_dir = base.replace(is_separator, MAIN_SEPARATOR_STR);
+        let mut partial = partial.to_string();
+        // On windows, this standardizes paths to use \
         let mut is_current_folder = false;
 
         // Fetch the lib dirs
@@ -58,7 +65,8 @@ impl Completer for DotNuCompletion {
             };
 
         // Check if the base_dir is a folder
-        if base_dir != format!(".{SEP}") {
+        // rsplit_once removes the separator
+        if base_dir != "." {
             // Add the base dir into the directories to be searched
             search_dirs.push(base_dir.clone());
 
@@ -83,16 +91,21 @@ impl Completer for DotNuCompletion {
         // and transform them into suggestions
         let output: Vec<Suggestion> = search_dirs
             .into_iter()
-            .flat_map(|it| {
-                file_path_completion(span, &partial, &it, options)
+            .flat_map(|search_dir| {
+                let completions = file_path_completion(span, &partial, &search_dir, options);
+                completions
                     .into_iter()
-                    .filter(|it| {
+                    .filter(move |it| {
                         // Different base dir, so we list the .nu files or folders
                         if !is_current_folder {
                             it.1.ends_with(".nu") || it.1.ends_with(SEP)
                         } else {
-                            // Lib dirs, so we filter only the .nu files
-                            it.1.ends_with(".nu")
+                            // Lib dirs, so we filter only the .nu files or directory modules
+                            if it.1.ends_with(SEP) {
+                                Path::new(&search_dir).join(&it.1).join("mod.nu").exists()
+                            } else {
+                                it.1.ends_with(".nu")
+                            }
                         }
                     })
                     .map(move |x| Suggestion {

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

@@ -1,16 +1,16 @@
-use crate::completions::{Completer, CompletionOptions};
+use crate::completions::{
+    completion_common::{adjust_if_intermediate, complete_item, AdjustView},
+    Completer, CompletionOptions, SortBy,
+};
 use nu_protocol::{
     engine::{EngineState, StateWorkingSet},
     levenshtein_distance, Span,
 };
+use nu_utils::IgnoreCaseExt;
 use reedline::Suggestion;
-use std::path::{is_separator, Path};
+use std::path::{Path, MAIN_SEPARATOR as SEP};
 use std::sync::Arc;
 
-use super::SortBy;
-
-const SEP: char = std::path::MAIN_SEPARATOR;
-
 #[derive(Clone)]
 pub struct FileCompletion {
     engine_state: Arc<EngineState>,
@@ -25,28 +25,38 @@ impl FileCompletion {
 impl Completer for FileCompletion {
     fn fetch(
         &mut self,
-        _: &StateWorkingSet,
+        working_set: &StateWorkingSet,
         prefix: Vec<u8>,
         span: Span,
         offset: usize,
         _: usize,
         options: &CompletionOptions,
     ) -> Vec<Suggestion> {
-        let cwd = self.engine_state.current_work_dir();
-        let prefix = String::from_utf8_lossy(&prefix).to_string();
-        let output: Vec<_> = file_path_completion(span, &prefix, &cwd, options)
-            .into_iter()
-            .map(move |x| Suggestion {
-                value: x.1,
-                description: None,
-                extra: None,
-                span: reedline::Span {
-                    start: x.0.start - offset,
-                    end: x.0.end - offset,
-                },
-                append_whitespace: false,
-            })
-            .collect();
+        let AdjustView {
+            prefix,
+            span,
+            readjusted,
+        } = adjust_if_intermediate(&prefix, working_set, span);
+
+        let output: Vec<_> = complete_item(
+            readjusted,
+            span,
+            &prefix,
+            &self.engine_state.current_work_dir(),
+            options,
+        )
+        .into_iter()
+        .map(move |x| Suggestion {
+            value: x.1,
+            description: None,
+            extra: None,
+            span: reedline::Span {
+                start: x.0.start - offset,
+                end: x.0.end - offset,
+            },
+            append_whitespace: false,
+        })
+        .collect();
 
         output
     }
@@ -60,7 +70,12 @@ impl Completer for FileCompletion {
 
         match self.get_sort_by() {
             SortBy::Ascending => {
-                sorted_items.sort_by(|a, b| a.value.cmp(&b.value));
+                sorted_items.sort_by(|a, b| {
+                    // Ignore trailing slashes in folder names when sorting
+                    a.value
+                        .trim_end_matches(SEP)
+                        .cmp(b.value.trim_end_matches(SEP))
+                });
             }
             SortBy::LevenshteinDistance => {
                 sorted_items.sort_by(|a, b| {
@@ -97,84 +112,13 @@ impl Completer for FileCompletion {
     }
 }
 
-pub fn partial_from(input: &str) -> (String, String) {
-    let partial = input.replace('`', "");
-
-    // If partial is only a word we want to search in the current dir
-    let (base, rest) = partial.rsplit_once(is_separator).unwrap_or((".", &partial));
-    // On windows, this standardizes paths to use \
-    let mut base = base.replace(is_separator, &SEP.to_string());
-
-    // rsplit_once removes the separator
-    base.push(SEP);
-
-    (base.to_string(), rest.to_string())
-}
-
 pub fn file_path_completion(
     span: nu_protocol::Span,
     partial: &str,
     cwd: &str,
     options: &CompletionOptions,
 ) -> Vec<(nu_protocol::Span, String)> {
-    let original_input = partial;
-    let (base_dir_name, partial) = partial_from(partial);
-
-    let base_dir = nu_path::expand_path_with(&base_dir_name, cwd);
-    // This check is here as base_dir.read_dir() with base_dir == "" will open the current dir
-    // which we don't want in this case (if we did, base_dir would already be ".")
-    if base_dir == Path::new("") {
-        return Vec::new();
-    }
-
-    if let Ok(result) = base_dir.read_dir() {
-        return result
-            .filter_map(|entry| {
-                entry.ok().and_then(|entry| {
-                    let mut file_name = entry.file_name().to_string_lossy().into_owned();
-                    if matches(&partial, &file_name, options) {
-                        let mut path = if prepend_base_dir(original_input, &base_dir_name) {
-                            format!("{base_dir_name}{file_name}")
-                        } else {
-                            file_name.to_string()
-                        };
-
-                        if entry.path().is_dir() {
-                            path.push(SEP);
-                            file_name.push(SEP);
-                        }
-
-                        // Fix files or folders with quotes or hashes
-                        if path.contains('\'')
-                            || path.contains('"')
-                            || path.contains(' ')
-                            || path.contains('#')
-                            || path.contains('(')
-                            || path.contains(')')
-                            || path.starts_with('0')
-                            || path.starts_with('1')
-                            || path.starts_with('2')
-                            || path.starts_with('3')
-                            || path.starts_with('4')
-                            || path.starts_with('5')
-                            || path.starts_with('6')
-                            || path.starts_with('7')
-                            || path.starts_with('8')
-                            || path.starts_with('9')
-                        {
-                            path = format!("`{path}`");
-                        }
-
-                        Some((span, path))
-                    } else {
-                        None
-                    }
-                })
-            })
-            .collect();
-    }
-
-    Vec::new()
+    complete_item(false, span, partial, cwd, options)
 }
 
 pub fn matches(partial: &str, from: &str, options: &CompletionOptions) -> bool {
@@ -182,28 +126,8 @@ pub fn matches(partial: &str, from: &str, options: &CompletionOptions) -> bool {
     if !options.case_sensitive {
         return options
             .match_algorithm
-            .matches_str(&from.to_ascii_lowercase(), &partial.to_ascii_lowercase());
+            .matches_str(&from.to_folded_case(), &partial.to_folded_case());
     }
 
     options.match_algorithm.matches_str(from, partial)
 }
-
-/// Returns whether the base_dir should be prepended to the file path
-pub fn prepend_base_dir(input: &str, base_dir: &str) -> bool {
-    if base_dir == format!(".{SEP}") {
-        // if the current base_dir path is the local folder we only add a "./" prefix if the user
-        // input already includes a local folder prefix.
-        let manually_entered = {
-            let mut chars = input.chars();
-            let first_char = chars.next();
-            let second_char = chars.next();
-
-            first_char == Some('.') && second_char.map(is_separator).unwrap_or(false)
-        };
-
-        manually_entered
-    } else {
-        // always prepend the base dir if it is a subfolder
-        true
-    }
-}

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

@@ -1,6 +1,7 @@
 mod base;
 mod command_completions;
 mod completer;
+mod completion_common;
 mod completion_options;
 mod custom_completions;
 mod directory_completions;
@@ -16,8 +17,6 @@ pub use completion_options::{CompletionOptions, MatchAlgorithm, SortBy};
 pub use custom_completions::CustomCompletion;
 pub use directory_completions::DirectoryCompletion;
 pub use dotnu_completions::DotNuCompletion;
-pub use file_completions::{
-    file_path_completion, matches, partial_from, prepend_base_dir, FileCompletion,
-};
+pub use file_completions::{file_path_completion, matches, FileCompletion};
 pub use flag_completions::FlagCompletion;
 pub use variable_completions::VariableCompletion;

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

@@ -43,10 +43,8 @@ impl Completer for VariableCompletion {
         options: &CompletionOptions,
     ) -> Vec<Suggestion> {
         let mut output = vec![];
-        let builtins = ["$nu", "$in", "$env", "$nothing"];
-        let var_str = std::str::from_utf8(&self.var_context.0)
-            .unwrap_or("")
-            .to_lowercase();
+        let builtins = ["$nu", "$in", "$env"];
+        let var_str = std::str::from_utf8(&self.var_context.0).unwrap_or("");
         let var_id = working_set.find_variable(&self.var_context.0);
         let current_span = reedline::Span {
             start: span.start - offset,
@@ -57,7 +55,7 @@ impl Completer for VariableCompletion {
         // Completions for the given variable
         if !var_str.is_empty() {
             // Completion for $env.<tab>
-            if var_str.as_str() == "$env" {
+            if var_str == "$env" {
                 let env_vars = self.stack.get_env_vars(&self.engine_state);
 
                 // Return nested values
@@ -109,7 +107,7 @@ impl Completer for VariableCompletion {
             }
 
             // Completions for $nu.<tab>
-            if var_str.as_str() == "$nu" {
+            if var_str == "$nu" {
                 // Eval nu var
                 if let Ok(nuval) = eval_variable(
                     &self.engine_state,
@@ -235,15 +233,11 @@ fn nested_suggestions(
     let value = recursive_value(val, sublevels);
 
     match value {
-        Value::Record {
-            cols,
-            vals: _,
-            span: _,
-        } => {
+        Value::Record { val, .. } => {
             // Add all the columns as completion
-            for item in cols {
+            for (col, _) in val.into_iter() {
                 output.push(Suggestion {
-                    value: item,
+                    value: col,
                     description: None,
                     extra: None,
                     span: current_span,
@@ -267,7 +261,7 @@ fn nested_suggestions(
 
             output
         }
-        Value::List { vals, span: _ } => {
+        Value::List { vals, .. } => {
             for column_name in get_columns(vals.as_slice()) {
                 output.push(Suggestion {
                     value: column_name,
@@ -288,13 +282,10 @@ fn nested_suggestions(
 fn recursive_value(val: Value, sublevels: Vec<Vec<u8>>) -> Value {
     // Go to next sublevel
     if let Some(next_sublevel) = sublevels.clone().into_iter().next() {
+        let span = val.span();
         match val {
-            Value::Record {
-                cols,
-                vals,
-                span: _,
-            } => {
-                for item in cols.into_iter().zip(vals.into_iter()) {
+            Value::Record { val, .. } => {
+                for item in val {
                     // Check if index matches with sublevel
                     if item.0.as_bytes().to_vec() == next_sublevel {
                         // If matches try to fetch recursively the next
@@ -303,11 +294,9 @@ fn recursive_value(val: Value, sublevels: Vec<Vec<u8>>) -> Value {
                 }
 
                 // Current sublevel value not found
-                return Value::Nothing {
-                    span: Span::unknown(),
-                };
+                return Value::nothing(span);
             }
-            Value::LazyRecord { val, span: _ } => {
+            Value::LazyRecord { val, .. } => {
                 for col in val.column_names() {
                     if col.as_bytes().to_vec() == next_sublevel {
                         return recursive_value(
@@ -318,15 +307,13 @@ fn recursive_value(val: Value, sublevels: Vec<Vec<u8>>) -> Value {
                 }
 
                 // Current sublevel value not found
-                return Value::Nothing {
-                    span: Span::unknown(),
-                };
+                return Value::nothing(span);
             }
-            Value::List { vals, 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 }
+                            Value::list(vals, span)
                                 .get_data_by_key(&col)
                                 .unwrap_or_default(),
                             sublevels.into_iter().skip(1).collect(),
@@ -335,9 +322,7 @@ fn recursive_value(val: Value, sublevels: Vec<Vec<u8>>) -> Value {
                 }
 
                 // Current sublevel value not found
-                return Value::Nothing {
-                    span: Span::unknown(),
-                };
+                return Value::nothing(span);
             }
             _ => return val,
         }

crates/nu-cli/src/eval_cmds.rs

@@ -28,13 +28,17 @@ pub fn evaluate_commands(
     let (block, delta) = {
         if let Some(ref t_mode) = table_mode {
             let mut config = engine_state.get_config().clone();
-            config.table_mode = t_mode.as_string()?;
-            engine_state.set_config(&config);
+            config.table_mode = t_mode.as_string()?.parse().unwrap_or_default();
+            engine_state.set_config(config);
         }
 
         let mut working_set = StateWorkingSet::new(engine_state);
 
         let output = parse(&mut working_set, None, commands.item.as_bytes(), false);
+        if let Some(warning) = working_set.parse_warnings.first() {
+            report_error(&working_set, warning);
+        }
+
         if let Some(err) = working_set.parse_errors.first() {
             report_error(&working_set, err);
 
@@ -55,7 +59,7 @@ pub fn evaluate_commands(
         Ok(pipeline_data) => {
             let mut config = engine_state.get_config().clone();
             if let Some(t_mode) = table_mode {
-                config.table_mode = t_mode.as_string()?;
+                config.table_mode = t_mode.as_string()?.parse().unwrap_or_default();
             }
             crate::eval_file::print_table_or_error(engine_state, stack, pipeline_data, &mut config)
         }

crates/nu-cli/src/eval_file.rs

@@ -2,6 +2,7 @@ use crate::util::eval_source;
 use log::info;
 use log::trace;
 use miette::{IntoDiagnostic, Result};
+use nu_engine::eval_block;
 use nu_engine::{convert_env_values, current_dir};
 use nu_parser::parse;
 use nu_path::canonicalize_with;
@@ -9,7 +10,7 @@ use nu_protocol::report_error;
 use nu_protocol::{
     ast::Call,
     engine::{EngineState, Stack, StateWorkingSet},
-    Config, PipelineData, ShellError, Span, Type, Value,
+    Config, PipelineData, ShellError, Span, Value,
 };
 use nu_utils::stdout_write_all_and_flush;
 
@@ -34,10 +35,10 @@ pub fn evaluate_file(
         let working_set = StateWorkingSet::new(engine_state);
         report_error(
             &working_set,
-            &ShellError::FileNotFoundCustom(
-                format!("Could not access file '{}': {:?}", path, e.to_string()),
-                Span::unknown(),
-            ),
+            &ShellError::FileNotFoundCustom {
+                msg: format!("Could not access file '{}': {:?}", path, e.to_string()),
+                span: Span::unknown(),
+            },
         );
         std::process::exit(1);
     });
@@ -46,13 +47,13 @@ pub fn evaluate_file(
         let working_set = StateWorkingSet::new(engine_state);
         report_error(
             &working_set,
-            &ShellError::NonUtf8Custom(
-                format!(
+            &ShellError::NonUtf8Custom {
+                msg: format!(
                     "Input file name '{}' is not valid UTF8",
                     file_path.to_string_lossy()
                 ),
-                Span::unknown(),
-            ),
+                span: Span::unknown(),
+            },
         );
         std::process::exit(1);
     });
@@ -63,14 +64,14 @@ pub fn evaluate_file(
             let working_set = StateWorkingSet::new(engine_state);
             report_error(
                 &working_set,
-                &ShellError::FileNotFoundCustom(
-                    format!(
+                &ShellError::FileNotFoundCustom {
+                    msg: format!(
                         "Could not read file '{}': {:?}",
                         file_path_str,
                         e.to_string()
                     ),
-                    Span::unknown(),
-                ),
+                    span: Span::unknown(),
+                },
             );
             std::process::exit(1);
         });
@@ -81,10 +82,10 @@ pub fn evaluate_file(
         let working_set = StateWorkingSet::new(engine_state);
         report_error(
             &working_set,
-            &ShellError::FileNotFoundCustom(
-                format!("The file path '{file_path_str}' does not have a parent"),
-                Span::unknown(),
-            ),
+            &ShellError::FileNotFoundCustom {
+                msg: format!("The file path '{file_path_str}' does not have a parent"),
+                span: Span::unknown(),
+            },
         );
         std::process::exit(1);
     });
@@ -97,24 +98,76 @@ pub fn evaluate_file(
         "CURRENT_FILE".to_string(),
         Value::string(file_path.to_string_lossy(), Span::unknown()),
     );
+    stack.add_env_var(
+        "PROCESS_PATH".to_string(),
+        Value::string(path, Span::unknown()),
+    );
+
+    let source_filename = file_path
+        .file_name()
+        .expect("internal error: script missing filename");
 
     let mut working_set = StateWorkingSet::new(engine_state);
     trace!("parsing file: {}", file_path_str);
-    let _ = parse(&mut working_set, Some(file_path_str), &file, false);
+    let block = parse(&mut working_set, Some(file_path_str), &file, false);
 
-    if working_set.find_decl(b"main", &Type::Any).is_some() {
+    if let Some(err) = working_set.parse_errors.first() {
+        report_error(&working_set, err);
+        std::process::exit(1);
+    }
+
+    for block in &mut working_set.delta.blocks {
+        if block.signature.name == "main" {
+            block.signature.name = source_filename.to_string_lossy().to_string();
+        } else if block.signature.name.starts_with("main ") {
+            block.signature.name =
+                source_filename.to_string_lossy().to_string() + " " + &block.signature.name[5..];
+        }
+    }
+
+    let _ = engine_state.merge_delta(working_set.delta);
+
+    if engine_state.find_decl(b"main", &[]).is_some() {
         let args = format!("main {}", args.join(" "));
 
-        if !eval_source(
+        let pipeline_data = eval_block(
             engine_state,
             stack,
-            &file,
-            file_path_str,
+            &block,
             PipelineData::empty(),
-            true,
-        ) {
-            std::process::exit(1);
+            false,
+            false,
+        );
+        let pipeline_data = match pipeline_data {
+            Err(ShellError::Return { .. }) => {
+                // allows early exists before `main` is run.
+                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);
+                }
+            }
+        }
+
         if !eval_source(
             engine_state,
             stack,
@@ -146,9 +199,9 @@ pub(crate) fn print_table_or_error(
     };
 
     // Change the engine_state config to use the passed in configuration
-    engine_state.set_config(config);
+    engine_state.set_config(config.clone());
 
-    if let PipelineData::Value(Value::Error { error }, ..) = &pipeline_data {
+    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);
@@ -195,7 +248,7 @@ pub(crate) fn print_table_or_error(
 
 fn print_or_exit(pipeline_data: PipelineData, engine_state: &mut EngineState, config: &Config) {
     for item in pipeline_data {
-        if let Value::Error { error } = item {
+        if let Value::Error { error, .. } = item {
             let working_set = StateWorkingSet::new(engine_state);
 
             report_error(&working_set, &*error);

crates/nu-cli/src/lib.rs

@@ -20,7 +20,7 @@ pub use config_files::eval_config_contents;
 pub use eval_cmds::evaluate_commands;
 pub use eval_file::evaluate_file;
 pub use menus::{DescriptionMenu, NuHelpCompleter};
-pub use nu_command::util::get_init_cwd;
+pub use nu_cmd_base::util::get_init_cwd;
 pub use nu_highlight::NuHighlight;
 pub use print::Print;
 pub use prompt::NushellPrompt;

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

@@ -646,7 +646,10 @@ impl Menu for DescriptionMenu {
                 |lb| {
                     lb.replace_range(start..end, replacement);
                     let mut offset = lb.insertion_point();
-                    offset += lb.len().saturating_sub(end.saturating_sub(start));
+                    offset += lb
+                        .len()
+                        .saturating_sub(end.saturating_sub(start))
+                        .saturating_sub(start);
                     lb.set_insertion_point(offset);
                 },
                 UndoBehavior::CreateUndoPoint,

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

@@ -1,5 +1,6 @@
 use nu_engine::documentation::get_flags_section;
 use nu_protocol::{engine::EngineState, levenshtein_distance};
+use nu_utils::IgnoreCaseExt;
 use reedline::{Completer, Suggestion};
 use std::fmt::Write;
 use std::sync::Arc;
@@ -13,21 +14,19 @@ 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();
 
         //Vec<(Signature, Vec<Example>, bool, bool)> {
         let mut commands = full_commands
             .iter()
             .filter(|(sig, _, _, _, _)| {
-                sig.name.to_lowercase().contains(&line.to_lowercase())
-                    || sig.usage.to_lowercase().contains(&line.to_lowercase())
+                sig.name.to_folded_case().contains(&folded_line)
+                    || sig.usage.to_folded_case().contains(&folded_line)
                     || sig
                         .search_terms
                         .iter()
-                        .any(|term| term.to_lowercase().contains(&line.to_lowercase()))
-                    || sig
-                        .extra_usage
-                        .to_lowercase()
-                        .contains(&line.to_lowercase())
+                        .any(|term| term.to_folded_case().contains(&folded_line))
+                    || sig.extra_usage.to_folded_case().contains(&folded_line)
             })
             .collect::<Vec<_>>();
 
@@ -57,7 +56,7 @@ impl NuHelpCompleter {
                 let _ = write!(long_desc, "Usage:\r\n  > {}\r\n", sig.call_signature());
 
                 if !sig.named.is_empty() {
-                    long_desc.push_str(&get_flags_section(sig, |v| {
+                    long_desc.push_str(&get_flags_section(Some(&*self.0.clone()), sig, |v| {
                         v.into_string_parsable(", ", &self.0.config)
                     }))
                 }

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

@@ -80,24 +80,18 @@ fn convert_to_suggestions(
     only_buffer_difference: bool,
 ) -> Vec<Suggestion> {
     match value {
-        Value::Record { .. } => {
-            let text = value
-                .get_data_by_key("value")
+        Value::Record { val, .. } => {
+            let text = val
+                .get("value")
                 .and_then(|val| val.as_string().ok())
                 .unwrap_or_else(|| "No value key".to_string());
 
-            let description = value
-                .get_data_by_key("description")
-                .and_then(|val| val.as_string().ok());
+            let description = val.get("description").and_then(|val| val.as_string().ok());
 
-            let span = match value.get_data_by_key("span") {
-                Some(span @ Value::Record { .. }) => {
-                    let start = span
-                        .get_data_by_key("start")
-                        .and_then(|val| val.as_integer().ok());
-                    let end = span
-                        .get_data_by_key("end")
-                        .and_then(|val| val.as_integer().ok());
+            let span = match val.get("span") {
+                Some(Value::Record { val: span, .. }) => {
+                    let start = span.get("start").and_then(|val| val.as_int().ok());
+                    let end = span.get("end").and_then(|val| val.as_int().ok());
                     match (start, end) {
                         (Some(start), Some(end)) => {
                             let start = start.min(end);
@@ -126,12 +120,12 @@ fn convert_to_suggestions(
                 },
             };
 
-            let extra = match value.get_data_by_key("extra") {
+            let extra = match val.get("extra") {
                 Some(Value::List { vals, .. }) => {
                     let extra: Vec<String> = vals
-                        .into_iter()
+                        .iter()
                         .filter_map(|extra| match extra {
-                            Value::String { val, .. } => Some(val),
+                            Value::String { val, .. } => Some(val.clone()),
                             _ => None,
                         })
                         .collect();

crates/nu-cli/src/nu_highlight.rs

@@ -48,14 +48,9 @@ impl Command for NuHighlight {
                 Ok(line) => {
                     let highlights = highlighter.highlight(&line, line.len());
 
-                    Value::String {
-                        val: highlights.render_simple(),
-                        span: head,
-                    }
+                    Value::string(highlights.render_simple(), head)
                 }
-                Err(err) => Value::Error {
-                    error: Box::new(err),
-                },
+                Err(err) => Value::error(err, head),
             },
             ctrlc,
         )

crates/nu-cli/src/print.rs

@@ -16,7 +16,11 @@ impl Command for Print {
 
     fn signature(&self) -> Signature {
         Signature::build("print")
-            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .input_output_types(vec![
+                (Type::Nothing, Type::Nothing),
+                (Type::Any, Type::Nothing),
+            ])
+            .allow_variants_without_examples(true)
             .rest("rest", SyntaxShape::Any, "the values to print")
             .switch(
                 "no-newline",

crates/nu-cli/src/prompt.rs

@@ -1,3 +1,4 @@
+use crate::prompt_update::{POST_PROMPT_MARKER, PRE_PROMPT_MARKER};
 #[cfg(windows)]
 use nu_utils::enable_vt_processing;
 use reedline::DefaultPrompt;
@@ -11,6 +12,7 @@ use {
 /// Nushell prompt definition
 #[derive(Clone)]
 pub struct NushellPrompt {
+    shell_integration: bool,
     left_prompt_string: Option<String>,
     right_prompt_string: Option<String>,
     default_prompt_indicator: Option<String>,
@@ -20,15 +22,10 @@ pub struct NushellPrompt {
     render_right_prompt_on_last_line: bool,
 }
 
-impl Default for NushellPrompt {
-    fn default() -> Self {
-        NushellPrompt::new()
-    }
-}
-
 impl NushellPrompt {
-    pub fn new() -> NushellPrompt {
+    pub fn new(shell_integration: bool) -> NushellPrompt {
         NushellPrompt {
+            shell_integration,
             left_prompt_string: None,
             right_prompt_string: None,
             default_prompt_indicator: None,
@@ -109,10 +106,13 @@ impl Prompt for NushellPrompt {
             let prompt = default
                 .render_prompt_left()
                 .to_string()
-                .replace('\n', "\r\n")
-                + " ";
+                .replace('\n', "\r\n");
 
-            prompt.into()
+            if self.shell_integration {
+                format!("{PRE_PROMPT_MARKER}{prompt}{POST_PROMPT_MARKER}").into()
+            } else {
+                prompt.into()
+            }
         }
     }
 
@@ -144,11 +144,11 @@ impl Prompt for NushellPrompt {
             PromptEditMode::Vi(vi_mode) => match vi_mode {
                 PromptViMode::Normal => match &self.default_vi_normal_prompt_indicator {
                     Some(indicator) => indicator,
-                    None => ": ",
+                    None => "> ",
                 },
                 PromptViMode::Insert => match &self.default_vi_insert_prompt_indicator {
                     Some(indicator) => indicator,
-                    None => "> ",
+                    None => ": ",
                 },
             }
             .into(),

crates/nu-cli/src/prompt_update.rs

@@ -15,10 +15,19 @@ pub(crate) const PROMPT_INDICATOR: &str = "PROMPT_INDICATOR";
 pub(crate) const PROMPT_INDICATOR_VI_INSERT: &str = "PROMPT_INDICATOR_VI_INSERT";
 pub(crate) const PROMPT_INDICATOR_VI_NORMAL: &str = "PROMPT_INDICATOR_VI_NORMAL";
 pub(crate) const PROMPT_MULTILINE_INDICATOR: &str = "PROMPT_MULTILINE_INDICATOR";
+pub(crate) const TRANSIENT_PROMPT_COMMAND: &str = "TRANSIENT_PROMPT_COMMAND";
+pub(crate) const TRANSIENT_PROMPT_COMMAND_RIGHT: &str = "TRANSIENT_PROMPT_COMMAND_RIGHT";
+pub(crate) const TRANSIENT_PROMPT_INDICATOR: &str = "TRANSIENT_PROMPT_INDICATOR";
+pub(crate) const TRANSIENT_PROMPT_INDICATOR_VI_INSERT: &str =
+    "TRANSIENT_PROMPT_INDICATOR_VI_INSERT";
+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";
 // According to Daniel Imms @Tyriar, we need to do these this way:
 // <133 A><prompt><133 B><command><133 C><command output>
-const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
-const POST_PROMPT_MARKER: &str = "\x1b]133;B\x1b\\";
+pub(crate) const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
+pub(crate) const POST_PROMPT_MARKER: &str = "\x1b]133;B\x1b\\";
 
 fn get_prompt_string(
     prompt: &str,
@@ -29,13 +38,9 @@ fn get_prompt_string(
     stack
         .get_env_var(engine_state, prompt)
         .and_then(|v| match v {
-            Value::Closure {
-                val: block_id,
-                captures,
-                ..
-            } => {
-                let block = engine_state.get_block(block_id);
-                let mut stack = stack.captures_to_stack(&captures);
+            Value::Closure { val, .. } => {
+                let block = engine_state.get_block(val.block_id);
+                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());
@@ -91,12 +96,12 @@ fn get_prompt_string(
         })
 }
 
-pub(crate) fn update_prompt<'prompt>(
+pub(crate) fn update_prompt(
     config: &Config,
     engine_state: &EngineState,
     stack: &Stack,
-    nu_prompt: &'prompt mut NushellPrompt,
-) -> &'prompt dyn Prompt {
+    nu_prompt: &mut NushellPrompt,
+) {
     let mut stack = stack.clone();
 
     let left_prompt_string = get_prompt_string(PROMPT_COMMAND, config, engine_state, &mut stack);
@@ -139,9 +144,55 @@ pub(crate) fn update_prompt<'prompt>(
         (prompt_vi_insert_string, prompt_vi_normal_string),
         config.render_right_prompt_on_last_line,
     );
-
-    let ret_val = nu_prompt as &dyn Prompt;
     trace!("update_prompt {}:{}:{}", file!(), line!(), column!());
-
-    ret_val
+}
+
+/// Construct the transient prompt based on the normal nu_prompt
+pub(crate) fn make_transient_prompt(
+    config: &Config,
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    nu_prompt: &NushellPrompt,
+) -> Box<dyn Prompt> {
+    let mut nu_prompt = nu_prompt.clone();
+
+    if let Some(s) = get_prompt_string(TRANSIENT_PROMPT_COMMAND, config, engine_state, stack) {
+        nu_prompt.update_prompt_left(Some(s))
+    }
+
+    if let Some(s) = get_prompt_string(TRANSIENT_PROMPT_COMMAND_RIGHT, config, engine_state, stack)
+    {
+        nu_prompt.update_prompt_right(Some(s), config.render_right_prompt_on_last_line)
+    }
+
+    if let Some(s) = get_prompt_string(TRANSIENT_PROMPT_INDICATOR, config, engine_state, stack) {
+        nu_prompt.update_prompt_indicator(Some(s))
+    }
+    if let Some(s) = get_prompt_string(
+        TRANSIENT_PROMPT_INDICATOR_VI_INSERT,
+        config,
+        engine_state,
+        stack,
+    ) {
+        nu_prompt.update_prompt_vi_insert(Some(s))
+    }
+    if let Some(s) = get_prompt_string(
+        TRANSIENT_PROMPT_INDICATOR_VI_NORMAL,
+        config,
+        engine_state,
+        stack,
+    ) {
+        nu_prompt.update_prompt_vi_normal(Some(s))
+    }
+
+    if let Some(s) = get_prompt_string(
+        TRANSIENT_PROMPT_MULTILINE_INDICATOR,
+        config,
+        engine_state,
+        stack,
+    ) {
+        nu_prompt.update_prompt_multiline(Some(s))
+    }
+
+    Box::new(nu_prompt)
 }

crates/nu-cli/src/repl.rs

@@ -7,26 +7,32 @@ use crate::{
 };
 use crossterm::cursor::SetCursorStyle;
 use log::{trace, warn};
-use miette::{IntoDiagnostic, Result};
+use miette::{ErrReport, IntoDiagnostic, Result};
+use nu_cmd_base::util::get_guaranteed_cwd;
+use nu_cmd_base::{hook::eval_hook, util::get_editor};
 use nu_color_config::StyleComputer;
-use nu_command::hook::eval_hook;
-use nu_command::util::get_guaranteed_cwd;
 use nu_engine::convert_env_values;
 use nu_parser::{lex, parse, trim_quotes_str};
 use nu_protocol::{
     config::NuCursorShape,
     engine::{EngineState, Stack, StateWorkingSet},
+    eval_const::create_nu_constant,
     report_error, report_error_new, HistoryFileFormat, PipelineData, ShellError, Span, Spanned,
-    Value,
+    Value, NU_VARIABLE_ID,
 };
 use nu_utils::utils::perf;
-use reedline::{CursorConfig, DefaultHinter, EditCommand, Emacs, SqliteBackedHistory, Vi};
+use reedline::{
+    CursorConfig, CwdAwareHinter, EditCommand, Emacs, FileBackedHistory, HistorySessionId,
+    Reedline, SqliteBackedHistory, Vi,
+};
 use std::{
-    io::{self, Write},
+    env::temp_dir,
+    io::{self, IsTerminal, Write},
+    path::Path,
     sync::atomic::Ordering,
     time::Instant,
 };
-use sysinfo::SystemExt;
+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>
@@ -46,13 +52,14 @@ pub fn evaluate_repl(
     load_std_lib: Option<Spanned<String>>,
     entire_start_time: Instant,
 ) -> Result<()> {
-    use nu_command::hook;
-    use reedline::{FileBackedHistory, Reedline, Signal};
-    let use_color = engine_state.get_config().use_ansi_coloring;
+    use nu_cmd_base::hook;
+    use reedline::Signal;
+    let config = engine_state.get_config();
+    let use_color = config.use_ansi_coloring;
 
     // Guard against invocation without a connected terminal.
     // reedline / crossterm event polling will fail without a connected tty
-    if !atty::is(atty::Stream::Stdin) {
+    if !std::io::stdin().is_terminal() {
         return Err(std::io::Error::new(
             std::io::ErrorKind::NotFound,
             "Nushell launched as a REPL, but STDIN is not a TTY; either launch in a valid terminal or provide arguments to invoke a script!",
@@ -62,7 +69,7 @@ pub fn evaluate_repl(
 
     let mut entry_num = 0;
 
-    let mut nu_prompt = NushellPrompt::new();
+    let mut nu_prompt = NushellPrompt::new(config.shell_integration);
 
     let start_time = std::time::Instant::now();
     // Translate environment variables from Strings to Values
@@ -89,13 +96,10 @@ pub fn evaluate_repl(
 
     let mut start_time = std::time::Instant::now();
     let mut line_editor = Reedline::create();
+    let temp_file = temp_dir().join(format!("{}.nu", uuid::Uuid::new_v4()));
 
     // Now that reedline is created, get the history session id and store it in engine_state
-    let hist_sesh = line_editor
-        .get_history_session_id()
-        .map(i64::from)
-        .unwrap_or(0);
-    engine_state.history_session_id = hist_sesh;
+    store_history_id_in_engine(engine_state, &line_editor);
     perf(
         "setup reedline",
         start_time,
@@ -105,16 +109,8 @@ pub fn evaluate_repl(
         use_color,
     );
 
-    let config = engine_state.get_config();
-    if config.bracketed_paste {
-        // try to enable bracketed paste
-        // It doesn't work on windows system: https://github.com/crossterm-rs/crossterm/issues/737
-        #[cfg(not(target_os = "windows"))]
-        let _ = line_editor.enable_bracketed_paste();
-    }
-
     // Setup history_isolation aka "history per session"
-    let history_isolation = config.history_isolation;
+    let history_isolation = engine_state.get_config().history_isolation;
     let history_session_id = if history_isolation {
         Reedline::create_history_session_id()
     } else {
@@ -127,21 +123,8 @@ pub fn evaluate_repl(
         engine_state.config.history_file_format,
     );
     if let Some(history_path) = history_path.as_deref() {
-        let history: Box<dyn reedline::History> = match engine_state.config.history_file_format {
-            HistoryFileFormat::PlainText => Box::new(
-                FileBackedHistory::with_file(
-                    config.max_history_size as usize,
-                    history_path.to_path_buf(),
-                )
-                .into_diagnostic()?,
-            ),
-            HistoryFileFormat::Sqlite => Box::new(
-                SqliteBackedHistory::with_file(history_path.to_path_buf()).into_diagnostic()?,
-            ),
-        };
-        line_editor = line_editor
-            .with_history_session_id(history_session_id)
-            .with_history(history);
+        line_editor =
+            update_line_editor_history(engine_state, history_path, line_editor, history_session_id)?
     };
     perf(
         "setup history",
@@ -152,17 +135,6 @@ pub fn evaluate_repl(
         use_color,
     );
 
-    start_time = std::time::Instant::now();
-    let sys = sysinfo::System::new();
-    perf(
-        "get sysinfo",
-        start_time,
-        file!(),
-        line!(),
-        column!(),
-        use_color,
-    );
-
     if let Some(s) = prerun_command {
         eval_source(
             engine_state,
@@ -177,6 +149,10 @@ pub fn evaluate_repl(
 
     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
+    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(
             engine_state,
@@ -188,6 +164,10 @@ pub fn evaluate_repl(
         );
     }
 
+    if engine_state.get_config().use_kitty_protocol && !reedline::kitty_protocol_available() {
+        warn!("Terminal doesn't support use_kitty_protocol config");
+    }
+
     loop {
         let loop_start_time = std::time::Instant::now();
 
@@ -222,20 +202,6 @@ pub fn evaluate_repl(
             use_color,
         );
 
-        start_time = std::time::Instant::now();
-        // Reset the SIGQUIT handler
-        if let Some(sig_quit) = engine_state.get_sig_quit() {
-            sig_quit.store(false, Ordering::SeqCst);
-        }
-        perf(
-            "reset sig_quit",
-            start_time,
-            file!(),
-            line!(),
-            column!(),
-            use_color,
-        );
-
         start_time = std::time::Instant::now();
         let config = engine_state.get_config();
 
@@ -243,13 +209,9 @@ pub fn evaluate_repl(
 
         // Find the configured cursor shapes for each mode
         let cursor_config = CursorConfig {
-            vi_insert: Some(map_nucursorshape_to_cursorshape(
-                config.cursor_shape_vi_insert,
-            )),
-            vi_normal: Some(map_nucursorshape_to_cursorshape(
-                config.cursor_shape_vi_normal,
-            )),
-            emacs: Some(map_nucursorshape_to_cursorshape(config.cursor_shape_emacs)),
+            vi_insert: map_nucursorshape_to_cursorshape(config.cursor_shape_vi_insert),
+            vi_normal: map_nucursorshape_to_cursorshape(config.cursor_shape_vi_normal),
+            emacs: map_nucursorshape_to_cursorshape(config.cursor_shape_emacs),
         };
         perf(
             "get config/cursor config",
@@ -263,6 +225,10 @@ pub fn evaluate_repl(
         start_time = std::time::Instant::now();
 
         line_editor = line_editor
+            .use_kitty_keyboard_enhancement(config.use_kitty_protocol)
+            // try to enable bracketed paste
+            // It doesn't work on windows system: https://github.com/crossterm-rs/crossterm/issues/737
+            .use_bracketed_paste(cfg!(not(target_os = "windows")) && config.bracketed_paste)
             .with_highlighter(Box::new(NuHighlighter {
                 engine_state: engine_reference.clone(),
                 config: config.clone(),
@@ -294,7 +260,7 @@ pub fn evaluate_repl(
             line_editor.with_hinter(Box::new({
                 // As of Nov 2022, "hints" color_config closures only get `null` passed in.
                 let style = style_computer.compute("hints", &Value::nothing(Span::unknown()));
-                DefaultHinter::default().with_style(style)
+                CwdAwareHinter::default().with_style(style)
             }))
         } else {
             line_editor.disable_hints()
@@ -324,23 +290,17 @@ pub fn evaluate_repl(
         );
 
         start_time = std::time::Instant::now();
-        let buffer_editor = if !config.buffer_editor.is_empty() {
-            Some(config.buffer_editor.clone())
-        } else {
-            stack
-                .get_env_var(engine_state, "EDITOR")
-                .map(|v| v.as_string().unwrap_or_default())
-                .filter(|v| !v.is_empty())
-                .or_else(|| {
-                    stack
-                        .get_env_var(engine_state, "VISUAL")
-                        .map(|v| v.as_string().unwrap_or_default())
-                        .filter(|v| !v.is_empty())
-                })
-        };
+        let buffer_editor = get_editor(engine_state, stack, Span::unknown());
 
-        line_editor = if let Some(buffer_editor) = buffer_editor {
-            line_editor.with_buffer_editor(buffer_editor, "nu".into())
+        line_editor = if let Ok((cmd, args)) = buffer_editor {
+            let mut command = std::process::Command::new(&cmd);
+            command.args(args).envs(
+                engine_state
+                    .render_env_vars()
+                    .into_iter()
+                    .filter_map(|(k, v)| v.as_string().ok().map(|v| (k, v))),
+            );
+            line_editor.with_buffer_editor(command, temp_file.clone())
         } else {
             line_editor
         };
@@ -403,7 +363,7 @@ pub fn evaluate_repl(
         // Right before we start our prompt and take input from the user,
         // fire the "pre_prompt" hook
         if let Some(hook) = config.hooks.pre_prompt.clone() {
-            if let Err(err) = eval_hook(engine_state, stack, None, vec![], &hook) {
+            if let Err(err) = eval_hook(engine_state, stack, None, vec![], &hook, "pre_prompt") {
                 report_error_new(engine_state, &err);
             }
         }
@@ -436,7 +396,9 @@ pub fn evaluate_repl(
 
         start_time = std::time::Instant::now();
         let config = &engine_state.get_config().clone();
-        let prompt = prompt_update::update_prompt(config, engine_state, stack, &mut nu_prompt);
+        prompt_update::update_prompt(config, engine_state, stack, &mut nu_prompt);
+        let transient_prompt =
+            prompt_update::make_transient_prompt(config, engine_state, stack, &nu_prompt);
         perf(
             "update_prompt",
             start_time,
@@ -449,12 +411,13 @@ pub fn evaluate_repl(
         entry_num += 1;
 
         start_time = std::time::Instant::now();
-        let input = line_editor.read_line(prompt);
+        line_editor = line_editor.with_transient_prompt(transient_prompt);
+        let input = line_editor.read_line(&nu_prompt);
         let shell_integration = config.shell_integration;
 
         match input {
             Ok(Signal::Success(s)) => {
-                let hostname = sys.host_name();
+                let hostname = System::host_name();
                 let history_supports_meta =
                     matches!(config.history_file_format, HistoryFileFormat::Sqlite);
                 if history_supports_meta && !s.is_empty() && line_editor.has_last_command_context()
@@ -474,30 +437,21 @@ pub fn evaluate_repl(
                 // hook
                 if let Some(hook) = config.hooks.pre_execution.clone() {
                     // Set the REPL buffer to the current command for the "pre_execution" hook
-                    let mut repl_buffer = engine_state
-                        .repl_buffer_state
-                        .lock()
-                        .expect("repl buffer state mutex");
-                    *repl_buffer = s.to_string();
-                    drop(repl_buffer);
+                    let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
+                    repl.buffer = s.to_string();
+                    drop(repl);
 
-                    if let Err(err) = eval_hook(engine_state, stack, None, vec![], &hook) {
+                    if let Err(err) =
+                        eval_hook(engine_state, stack, None, vec![], &hook, "pre_execution")
+                    {
                         report_error_new(engine_state, &err);
                     }
                 }
 
-                let mut repl_cursor = engine_state
-                    .repl_cursor_pos
-                    .lock()
-                    .expect("repl cursor pos mutex");
-                *repl_cursor = line_editor.current_insertion_point();
-                drop(repl_cursor);
-                let mut repl_buffer = engine_state
-                    .repl_buffer_state
-                    .lock()
-                    .expect("repl buffer state mutex");
-                *repl_buffer = line_editor.current_buffer_contents().to_string();
-                drop(repl_buffer);
+                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 {
                     run_ansi_sequence(PRE_EXECUTE_MARKER)?;
@@ -523,7 +477,10 @@ pub fn evaluate_repl(
 
                             report_error(
                                 &working_set,
-                                &ShellError::DirectoryNotFound(tokens.0[0].span, None),
+                                &ShellError::DirectoryNotFound {
+                                    dir: path.to_string_lossy().to_string(),
+                                    span: tokens.0[0].span,
+                                },
                             );
                         }
                         let path = nu_path::canonicalize_with(path, &cwd)
@@ -531,24 +488,12 @@ pub fn evaluate_repl(
                         (path.to_string_lossy().to_string(), tokens.0[0].span)
                     };
 
-                    stack.add_env_var(
-                        "OLDPWD".into(),
-                        Value::String {
-                            val: cwd.clone(),
-                            span: Span::unknown(),
-                        },
-                    );
+                    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
-                    stack.add_env_var(
-                        "PWD".into(),
-                        Value::String {
-                            val: path.clone(),
-                            span: Span::unknown(),
-                        },
-                    );
-                    let cwd = Value::String { val: cwd, span };
+                    stack.add_env_var("PWD".into(), Value::string(path.clone(), Span::unknown()));
+                    let cwd = Value::string(cwd, span);
 
                     let shells = stack.get_env_var(engine_state, "NUSHELL_SHELLS");
                     let mut shells = if let Some(v) = shells {
@@ -561,27 +506,24 @@ pub fn evaluate_repl(
 
                     let current_shell = stack.get_env_var(engine_state, "NUSHELL_CURRENT_SHELL");
                     let current_shell = if let Some(v) = current_shell {
-                        v.as_integer().unwrap_or_default() as usize
+                        v.as_int().unwrap_or_default() as usize
                     } else {
                         0
                     };
 
                     let last_shell = stack.get_env_var(engine_state, "NUSHELL_LAST_SHELL");
                     let last_shell = if let Some(v) = last_shell {
-                        v.as_integer().unwrap_or_default() as usize
+                        v.as_int().unwrap_or_default() as usize
                     } else {
                         0
                     };
 
-                    shells[current_shell] = Value::String { val: path, span };
+                    shells[current_shell] = Value::string(path, span);
 
-                    stack.add_env_var("NUSHELL_SHELLS".into(), Value::List { vals: shells, span });
+                    stack.add_env_var("NUSHELL_SHELLS".into(), Value::list(shells, span));
                     stack.add_env_var(
                         "NUSHELL_LAST_SHELL".into(),
-                        Value::Int {
-                            val: last_shell as i64,
-                            span,
-                        },
+                        Value::int(last_shell as i64, span),
                     );
                 } else if !s.trim().is_empty() {
                     trace!("eval source: {}", s);
@@ -620,10 +562,7 @@ pub fn evaluate_repl(
 
                 stack.add_env_var(
                     "CMD_DURATION_MS".into(),
-                    Value::String {
-                        val: format!("{}", cmd_duration.as_millis()),
-                        span: Span::unknown(),
-                    },
+                    Value::string(format!("{}", cmd_duration.as_millis()), Span::unknown()),
                 );
 
                 if history_supports_meta && !s.is_empty() && line_editor.has_last_command_context()
@@ -644,19 +583,29 @@ pub fn evaluate_repl(
                     if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
                         let path = cwd.as_string()?;
 
-                        // 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
-                            )
-                        ))?;
+                        // 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"))
+                        {
+                            // 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!("\x1b]633;P;Cwd={}\x1b\\", path))?;
+                        } else {
+                            // 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() {
@@ -675,23 +624,15 @@ pub fn evaluate_repl(
                     run_ansi_sequence(RESET_APPLICATION_MODE)?;
                 }
 
-                let mut repl_buffer = engine_state
-                    .repl_buffer_state
-                    .lock()
-                    .expect("repl buffer state mutex");
-                let mut repl_cursor_pos = engine_state
-                    .repl_cursor_pos
-                    .lock()
-                    .expect("repl cursor pos mutex");
+                let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
                 line_editor.run_edit_commands(&[
                     EditCommand::Clear,
-                    EditCommand::InsertString(repl_buffer.to_string()),
-                    EditCommand::MoveToPosition(*repl_cursor_pos),
+                    EditCommand::InsertString(repl.buffer.to_string()),
+                    EditCommand::MoveToPosition(repl.cursor_pos),
                 ]);
-                *repl_buffer = "".to_string();
-                drop(repl_buffer);
-                *repl_cursor_pos = 0;
-                drop(repl_cursor_pos);
+                repl.buffer = "".to_string();
+                repl.cursor_pos = 0;
+                drop(repl);
             }
             Ok(Signal::CtrlC) => {
                 // `Reedline` clears the line content. New prompt is shown
@@ -743,18 +684,62 @@ pub fn evaluate_repl(
     Ok(())
 }
 
-fn map_nucursorshape_to_cursorshape(shape: NuCursorShape) -> SetCursorStyle {
+fn store_history_id_in_engine(engine_state: &mut EngineState, line_editor: &Reedline) {
+    let session_id = line_editor
+        .get_history_session_id()
+        .map(i64::from)
+        .unwrap_or(0);
+
+    engine_state.history_session_id = session_id;
+}
+
+fn update_line_editor_history(
+    engine_state: &mut EngineState,
+    history_path: &Path,
+    line_editor: Reedline,
+    history_session_id: Option<HistorySessionId>,
+) -> Result<Reedline, ErrReport> {
+    let config = engine_state.get_config();
+    let history: Box<dyn reedline::History> = match engine_state.config.history_file_format {
+        HistoryFileFormat::PlainText => Box::new(
+            FileBackedHistory::with_file(
+                config.max_history_size as usize,
+                history_path.to_path_buf(),
+            )
+            .into_diagnostic()?,
+        ),
+        HistoryFileFormat::Sqlite => Box::new(
+            SqliteBackedHistory::with_file(
+                history_path.to_path_buf(),
+                history_session_id,
+                Some(chrono::Utc::now()),
+            )
+            .into_diagnostic()?,
+        ),
+    };
+    let line_editor = line_editor
+        .with_history_session_id(history_session_id)
+        .with_history_exclusion_prefix(Some(" ".into()))
+        .with_history(history);
+
+    store_history_id_in_engine(engine_state, &line_editor);
+
+    Ok(line_editor)
+}
+
+fn map_nucursorshape_to_cursorshape(shape: NuCursorShape) -> Option<SetCursorStyle> {
     match shape {
-        NuCursorShape::Block => SetCursorStyle::SteadyBlock,
-        NuCursorShape::UnderScore => SetCursorStyle::SteadyUnderScore,
-        NuCursorShape::Line => SetCursorStyle::SteadyBar,
-        NuCursorShape::BlinkBlock => SetCursorStyle::BlinkingBlock,
-        NuCursorShape::BlinkUnderScore => SetCursorStyle::BlinkingUnderScore,
-        NuCursorShape::BlinkLine => SetCursorStyle::BlinkingBar,
+        NuCursorShape::Block => Some(SetCursorStyle::SteadyBlock),
+        NuCursorShape::UnderScore => Some(SetCursorStyle::SteadyUnderScore),
+        NuCursorShape::Line => Some(SetCursorStyle::SteadyBar),
+        NuCursorShape::BlinkBlock => Some(SetCursorStyle::BlinkingBlock),
+        NuCursorShape::BlinkUnderScore => Some(SetCursorStyle::BlinkingUnderScore),
+        NuCursorShape::BlinkLine => Some(SetCursorStyle::BlinkingBar),
+        NuCursorShape::Inherit => None,
     }
 }
 
-pub fn get_command_finished_marker(stack: &Stack, engine_state: &EngineState) -> String {
+fn get_command_finished_marker(stack: &Stack, engine_state: &EngineState) -> String {
     let exit_code = stack
         .get_env_var(engine_state, "LAST_EXIT_CODE")
         .and_then(|e| e.as_i64().ok());
@@ -763,23 +748,21 @@ pub fn get_command_finished_marker(stack: &Stack, engine_state: &EngineState) ->
 }
 
 fn run_ansi_sequence(seq: &str) -> Result<(), ShellError> {
-    io::stdout().write_all(seq.as_bytes()).map_err(|e| {
-        ShellError::GenericError(
-            "Error writing ansi sequence".into(),
-            e.to_string(),
-            Some(Span::unknown()),
-            None,
-            Vec::new(),
-        )
-    })?;
-    io::stdout().flush().map_err(|e| {
-        ShellError::GenericError(
-            "Error flushing stdio".into(),
-            e.to_string(),
-            Some(Span::unknown()),
-            None,
-            Vec::new(),
-        )
+    io::stdout()
+        .write_all(seq.as_bytes())
+        .map_err(|e| ShellError::GenericError {
+            error: "Error writing ansi sequence".into(),
+            msg: e.to_string(),
+            span: Some(Span::unknown()),
+            help: None,
+            inner: vec![],
+        })?;
+    io::stdout().flush().map_err(|e| ShellError::GenericError {
+        error: "Error flushing stdio".into(),
+        msg: e.to_string(),
+        span: Some(Span::unknown()),
+        help: None,
+        inner: vec![],
     })
 }
 
@@ -803,14 +786,44 @@ fn looks_like_path(orig: &str) -> bool {
         || orig.starts_with('~')
         || orig.starts_with('/')
         || orig.starts_with('\\')
+        || orig.ends_with(std::path::MAIN_SEPARATOR)
+}
+
+#[cfg(windows)]
+#[test]
+fn looks_like_path_windows_drive_path_works() {
+    assert!(looks_like_path("C:"));
+    assert!(looks_like_path("D:\\"));
+    assert!(looks_like_path("E:/"));
+    assert!(looks_like_path("F:\\some_dir"));
+    assert!(looks_like_path("G:/some_dir"));
+}
+
+#[cfg(windows)]
+#[test]
+fn trailing_slash_looks_like_path() {
+    assert!(looks_like_path("foo\\"))
+}
+
+#[cfg(not(windows))]
+#[test]
+fn trailing_slash_looks_like_path() {
+    assert!(looks_like_path("foo/"))
 }
 
 #[test]
-fn looks_like_path_windows_drive_path_works() {
-    let on_windows = cfg!(windows);
-    assert_eq!(looks_like_path("C:"), on_windows);
-    assert_eq!(looks_like_path("D:\\"), on_windows);
-    assert_eq!(looks_like_path("E:/"), on_windows);
-    assert_eq!(looks_like_path("F:\\some_dir"), on_windows);
-    assert_eq!(looks_like_path("G:/some_dir"), on_windows);
+fn are_session_ids_in_sync() {
+    let engine_state = &mut EngineState::new();
+    let history_path_o =
+        crate::config_files::get_history_path("nushell", engine_state.config.history_file_format);
+    assert!(history_path_o.is_some());
+    let history_path = history_path_o.as_deref().unwrap();
+    let line_editor = reedline::Reedline::create();
+    let history_session_id = reedline::Reedline::create_history_session_id();
+    let line_editor =
+        update_line_editor_history(engine_state, history_path, line_editor, history_session_id);
+    assert_eq!(
+        i64::from(line_editor.unwrap().get_history_session_id().unwrap()),
+        engine_state.history_session_id
+    );
 }

crates/nu-cli/src/syntax_highlight.rs

@@ -2,7 +2,7 @@ use log::trace;
 use nu_ansi_term::Style;
 use nu_color_config::{get_matching_brackets_style, get_shape_color};
 use nu_parser::{flatten_block, parse, FlatShape};
-use nu_protocol::ast::{Argument, Block, Expr, Expression, PipelineElement};
+use nu_protocol::ast::{Argument, Block, Expr, Expression, PipelineElement, RecordItem};
 use nu_protocol::engine::{EngineState, StateWorkingSet};
 use nu_protocol::{Config, Span};
 use reedline::{Highlighter, StyledText};
@@ -17,10 +17,27 @@ impl Highlighter for NuHighlighter {
     fn highlight(&self, line: &str, _cursor: usize) -> StyledText {
         trace!("highlighting: {}", line);
 
+        let highlight_resolved_externals =
+            self.engine_state.get_config().highlight_resolved_externals;
         let mut working_set = StateWorkingSet::new(&self.engine_state);
         let block = parse(&mut working_set, None, line.as_bytes(), false);
         let (shapes, global_span_offset) = {
-            let shapes = flatten_block(&working_set, &block);
+            let mut shapes = flatten_block(&working_set, &block);
+            // Highlighting externals has a config point because of concerns that using which to resolve
+            // externals may slow down things too much.
+            if highlight_resolved_externals {
+                for (span, shape) in shapes.iter_mut() {
+                    if *shape == FlatShape::External {
+                        let str_contents =
+                            working_set.get_span_contents(Span::new(span.start, span.end));
+
+                        let str_word = String::from_utf8_lossy(str_contents).to_string();
+                        if which::which(str_word).ok().is_some() {
+                            *shape = FlatShape::ExternalResolved;
+                        }
+                    }
+                }
+            }
             (shapes, self.engine_state.next_span_start())
         };
 
@@ -59,7 +76,7 @@ impl Highlighter for NuHighlighter {
                 ($shape:expr, $span:expr, $text:expr) => {{
                     let spans = split_span_by_highlight_positions(
                         line,
-                        &$span,
+                        $span,
                         &matching_brackets_pos,
                         global_span_offset,
                     );
@@ -91,6 +108,7 @@ impl Highlighter for NuHighlighter {
                 FlatShape::InternalCall(_) => add_colored_token(&shape.1, next_token),
                 FlatShape::External => add_colored_token(&shape.1, next_token),
                 FlatShape::ExternalArg => add_colored_token(&shape.1, next_token),
+                FlatShape::ExternalResolved => add_colored_token(&shape.1, next_token),
                 FlatShape::Keyword => add_colored_token(&shape.1, next_token),
                 FlatShape::Literal => add_colored_token(&shape.1, next_token),
                 FlatShape::Operator => add_colored_token(&shape.1, next_token),
@@ -143,8 +161,8 @@ impl Highlighter for NuHighlighter {
 
 fn split_span_by_highlight_positions(
     line: &str,
-    span: &Span,
-    highlight_positions: &Vec<usize>,
+    span: Span,
+    highlight_positions: &[usize],
     global_span_offset: usize,
 ) -> Vec<(Span, bool)> {
     let mut start = span.start;
@@ -234,11 +252,11 @@ fn find_matching_block_end_in_block(
         for e in &p.elements {
             match e {
                 PipelineElement::Expression(_, e)
-                | PipelineElement::Redirection(_, _, e)
+                | PipelineElement::Redirection(_, _, e, _)
                 | PipelineElement::And(_, e)
                 | PipelineElement::Or(_, e)
                 | PipelineElement::SameTargetRedirection { cmd: (_, e), .. }
-                | PipelineElement::SeparateRedirection { out: (_, e), .. } => {
+                | PipelineElement::SeparateRedirection { out: (_, e, _), .. } => {
                     if e.span.contains(global_cursor_offset) {
                         if let Some(pos) = find_matching_block_end_in_expr(
                             line,
@@ -311,10 +329,10 @@ fn find_matching_block_end_in_expr(
             Expr::ImportPattern(_) => None,
             Expr::Overlay(_) => None,
             Expr::Signature(_) => None,
-            Expr::MatchPattern(_) => None,
             Expr::MatchBlock(_) => None,
             Expr::Nothing => None,
             Expr::Garbage => None,
+            Expr::Spread(_) => None,
 
             Expr::Table(hdr, rows) => {
                 if expr_last == global_cursor_offset {
@@ -346,9 +364,16 @@ fn find_matching_block_end_in_expr(
                     Some(expr_last)
                 } else {
                     // cursor is inside record
-                    for (k, v) in exprs {
-                        find_in_expr_or_continue!(k);
-                        find_in_expr_or_continue!(v);
+                    for expr in exprs {
+                        match expr {
+                            RecordItem::Pair(k, v) => {
+                                find_in_expr_or_continue!(k);
+                                find_in_expr_or_continue!(v);
+                            }
+                            RecordItem::Spread(_, record) => {
+                                find_in_expr_or_continue!(record);
+                            }
+                        }
                     }
                     None
                 }
@@ -360,6 +385,7 @@ fn find_matching_block_end_in_expr(
                         Argument::Named((_, _, opt_expr)) => opt_expr.as_ref(),
                         Argument::Positional(inner_expr) => Some(inner_expr),
                         Argument::Unknown(inner_expr) => Some(inner_expr),
+                        Argument::Spread(inner_expr) => Some(inner_expr),
                     };
 
                     if let Some(inner_expr) = opt_expr {

crates/nu-cli/src/util.rs

@@ -1,4 +1,4 @@
-use nu_command::hook::eval_hook;
+use nu_cmd_base::hook::eval_hook;
 use nu_engine::{eval_block, eval_block_with_early_return};
 use nu_parser::{escape_quote_string, lex, parse, unescape_unquote_string, Token, TokenContents};
 use nu_protocol::engine::StateWorkingSet;
@@ -43,13 +43,13 @@ fn gather_env_vars(
         let working_set = StateWorkingSet::new(engine_state);
         report_error(
             &working_set,
-            &ShellError::GenericError(
-                format!("Environment variable was not captured: {env_str}"),
-                "".to_string(),
-                None,
-                Some(msg.into()),
-                Vec::new(),
-            ),
+            &ShellError::GenericError {
+                error: format!("Environment variable was not captured: {env_str}"),
+                msg: "".into(),
+                span: None,
+                help: Some(msg.into()),
+                inner: vec![],
+            },
         );
     }
 
@@ -75,15 +75,15 @@ fn gather_env_vars(
             let working_set = StateWorkingSet::new(engine_state);
             report_error(
                 &working_set,
-                &ShellError::GenericError(
-                    "Current directory is not a valid utf-8 path".to_string(),
-                    "".to_string(),
-                    None,
-                    Some(format!(
+                &ShellError::GenericError {
+                    error: "Current directory is not a valid utf-8 path".into(),
+                    msg: "".into(),
+                    span: None,
+                    help: Some(format!(
                         "Retrieving current directory failed: {init_cwd:?} not a valid utf-8 path"
                     )),
-                    Vec::new(),
-                ),
+                    inner: vec![],
+                },
             );
         }
     }
@@ -105,13 +105,13 @@ fn gather_env_vars(
             span: full_span,
         } = token
         {
-            let contents = engine_state.get_span_contents(&full_span);
+            let contents = engine_state.get_span_contents(full_span);
             let (parts, _) = lex(contents, full_span.start, &[], &[b'='], true);
 
             let name = if let Some(Token {
                 contents: TokenContents::Item,
                 span,
-            }) = parts.get(0)
+            }) = parts.first()
             {
                 let mut working_set = StateWorkingSet::new(engine_state);
                 let bytes = working_set.get_span_contents(*span);
@@ -185,10 +185,7 @@ fn gather_env_vars(
                     continue;
                 }
 
-                Value::String {
-                    val: bytes,
-                    span: *span,
-                }
+                Value::string(bytes, *span)
             } else {
                 report_capture_error(
                     engine_state,
@@ -223,6 +220,10 @@ pub fn eval_source(
             source,
             false,
         );
+        if let Some(warning) = working_set.parse_warnings.first() {
+            report_error(&working_set, warning);
+        }
+
         if let Some(err) = working_set.parse_errors.first() {
             set_last_exit_code(stack, 1);
             report_error(&working_set, err);
@@ -257,7 +258,14 @@ pub fn eval_source(
             {
                 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) {
+                match eval_hook(
+                    engine_state,
+                    stack,
+                    Some(pipeline_data),
+                    vec![],
+                    &hook,
+                    "display_output",
+                ) {
                     Err(err) => {
                         result = Err(err);
                     }

crates/nu-cli/tests/completions.rs

@@ -1,11 +1,16 @@
 pub mod support;
 
+use std::path::PathBuf;
+
 use nu_cli::NuCompleter;
 use nu_parser::parse;
 use nu_protocol::engine::StateWorkingSet;
 use reedline::{Completer, Suggestion};
 use rstest::{fixture, rstest};
-use support::{completions_helpers::new_quote_engine, file, folder, match_suggestions, new_engine};
+use support::{
+    completions_helpers::{new_partial_engine, new_quote_engine},
+    file, folder, match_suggestions, new_engine,
+};
 
 #[fixture]
 fn completer() -> NuCompleter {
@@ -54,6 +59,29 @@ fn extern_completer() -> NuCompleter {
     NuCompleter::new(std::sync::Arc::new(engine), stack)
 }
 
+#[fixture]
+fn custom_completer() -> NuCompleter {
+    // Create a new engine
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Add record value as example
+    let record = r#"
+        let external_completer = {|spans| 
+            $spans
+        }
+
+        $env.config.completions.external = {
+            enable: true
+            max_results: 100
+            completer: $external_completer
+        }
+    "#;
+    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    // Instantiate a new completer
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
+}
+
 #[test]
 fn variables_dollar_sign_with_varialblecompletion() {
     let (_, _, engine, stack) = new_engine();
@@ -63,7 +91,7 @@ fn variables_dollar_sign_with_varialblecompletion() {
     let target_dir = "$ ";
     let suggestions = completer.complete(target_dir, target_dir.len());
 
-    assert_eq!(7, suggestions.len());
+    assert_eq!(8, suggestions.len());
 }
 
 #[rstest]
@@ -116,15 +144,34 @@ fn dotnu_completions() {
     let completion_str = "source-env ".to_string();
     let suggestions = completer.complete(&completion_str, completion_str.len());
 
-    assert_eq!(1, suggestions.len());
-    assert_eq!("custom_completion.nu", suggestions.get(0).unwrap().value);
+    assert_eq!(2, suggestions.len());
+    assert_eq!("custom_completion.nu", suggestions.first().unwrap().value);
+    #[cfg(windows)]
+    assert_eq!("directory_completion\\", suggestions.get(1).unwrap().value);
+    #[cfg(not(windows))]
+    assert_eq!("directory_completion/", suggestions.get(1).unwrap().value);
 
     // Test use completion
     let completion_str = "use ".to_string();
     let suggestions = completer.complete(&completion_str, completion_str.len());
 
-    assert_eq!(1, suggestions.len());
-    assert_eq!("custom_completion.nu", suggestions.get(0).unwrap().value);
+    assert_eq!(2, suggestions.len());
+    assert_eq!("custom_completion.nu", suggestions.first().unwrap().value);
+    #[cfg(windows)]
+    assert_eq!("directory_completion\\", suggestions.get(1).unwrap().value);
+    #[cfg(not(windows))]
+    assert_eq!("directory_completion/", suggestions.get(1).unwrap().value);
+
+    // Test overlay use completion
+    let completion_str = "overlay use ".to_string();
+    let suggestions = completer.complete(&completion_str, completion_str.len());
+
+    assert_eq!(2, suggestions.len());
+    assert_eq!("custom_completion.nu", suggestions.first().unwrap().value);
+    #[cfg(windows)]
+    assert_eq!("directory_completion\\", suggestions.get(1).unwrap().value);
+    #[cfg(not(windows))]
+    assert_eq!("directory_completion/", suggestions.get(1).unwrap().value);
 }
 
 #[test]
@@ -136,30 +183,30 @@ fn external_completer_trailing_space() {
 
     let suggestions = run_external_completion(block, &input);
     assert_eq!(3, suggestions.len());
-    assert_eq!("gh", suggestions.get(0).unwrap().value);
+    assert_eq!("gh", suggestions.first().unwrap().value);
     assert_eq!("alias", suggestions.get(1).unwrap().value);
     assert_eq!("", suggestions.get(2).unwrap().value);
 }
 
 #[test]
 fn external_completer_no_trailing_space() {
-    let block = "let external_completer = {|spans| $spans}";
+    let block = "{|spans| $spans}";
     let input = "gh alias".to_string();
 
     let suggestions = run_external_completion(block, &input);
     assert_eq!(2, suggestions.len());
-    assert_eq!("gh", suggestions.get(0).unwrap().value);
+    assert_eq!("gh", suggestions.first().unwrap().value);
     assert_eq!("alias", suggestions.get(1).unwrap().value);
 }
 
 #[test]
 fn external_completer_pass_flags() {
-    let block = "let external_completer = {|spans| $spans}";
+    let block = "{|spans| $spans}";
     let input = "gh api --".to_string();
 
     let suggestions = run_external_completion(block, &input);
     assert_eq!(3, suggestions.len());
-    assert_eq!("gh", suggestions.get(0).unwrap().value);
+    assert_eq!("gh", suggestions.first().unwrap().value);
     assert_eq!("api", suggestions.get(1).unwrap().value);
     assert_eq!("--", suggestions.get(2).unwrap().value);
 }
@@ -180,6 +227,7 @@ fn file_completions() {
     let expected_paths: Vec<String> = vec![
         folder(dir.join("another")),
         file(dir.join("custom_completion.nu")),
+        folder(dir.join("directory_completion")),
         file(dir.join("nushell")),
         folder(dir.join("test_a")),
         folder(dir.join("test_b")),
@@ -201,6 +249,87 @@ fn file_completions() {
     match_suggestions(expected_paths, suggestions);
 }
 
+#[test]
+fn partial_completions() {
+    // Create a new engine
+    let (dir, _, engine, stack) = new_partial_engine();
+
+    // Instantiate a new completer
+    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")));
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![
+        folder(dir.join("partial_a")),
+        folder(dir.join("partial_b")),
+        folder(dir.join("partial_c")),
+    ];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+
+    // Test completions for the files whose name begin with "h"
+    // and are present under directories whose names begin with "pa"
+    let dir_str = file(dir.join("pa").join("h"));
+    let target_dir = format!("cp {dir_str}");
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![
+        file(dir.join("partial_a").join("hello")),
+        file(dir.join("partial_a").join("hola")),
+        file(dir.join("partial_b").join("hello_b")),
+        file(dir.join("partial_b").join("hi_b")),
+        file(dir.join("partial_c").join("hello_c")),
+    ];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+
+    // Test completion for all files under directories whose names begin with "pa"
+    let dir_str = folder(dir.join("pa"));
+    let target_dir = format!("ls {dir_str}");
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![
+        file(dir.join("partial_a").join("anotherfile")),
+        file(dir.join("partial_a").join("hello")),
+        file(dir.join("partial_a").join("hola")),
+        file(dir.join("partial_b").join("hello_b")),
+        file(dir.join("partial_b").join("hi_b")),
+        file(dir.join("partial_c").join("hello_c")),
+    ];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+
+    // Test completion for a single file
+    let dir_str = file(dir.join("fi").join("so"));
+    let target_dir = format!("rm {dir_str}");
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![file(dir.join("final_partial").join("somefile"))];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+
+    // Test completion where there is a sneaky `..` in the path
+    let dir_str = file(dir.join("par").join("..").join("fi").join("so"));
+    let target_dir = format!("rm {dir_str}");
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![file(dir.join("final_partial").join("somefile"))];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+}
+
 #[test]
 fn command_ls_with_filecompletion() {
     let (_, _, engine, stack) = new_engine();
@@ -214,6 +343,7 @@ fn command_ls_with_filecompletion() {
     let expected_paths: Vec<String> = vec![
         "another\\".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion\\".to_string(),
         "nushell".to_string(),
         "test_a\\".to_string(),
         "test_b\\".to_string(),
@@ -224,6 +354,7 @@ fn command_ls_with_filecompletion() {
     let expected_paths: Vec<String> = vec![
         "another/".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion/".to_string(),
         "nushell".to_string(),
         "test_a/".to_string(),
         "test_b/".to_string(),
@@ -246,6 +377,7 @@ fn command_open_with_filecompletion() {
     let expected_paths: Vec<String> = vec![
         "another\\".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion\\".to_string(),
         "nushell".to_string(),
         "test_a\\".to_string(),
         "test_b\\".to_string(),
@@ -256,6 +388,7 @@ fn command_open_with_filecompletion() {
     let expected_paths: Vec<String> = vec![
         "another/".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion/".to_string(),
         "nushell".to_string(),
         "test_a/".to_string(),
         "test_b/".to_string(),
@@ -279,6 +412,7 @@ fn command_rm_with_globcompletion() {
     let expected_paths: Vec<String> = vec![
         "another\\".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion\\".to_string(),
         "nushell".to_string(),
         "test_a\\".to_string(),
         "test_b\\".to_string(),
@@ -289,6 +423,7 @@ fn command_rm_with_globcompletion() {
     let expected_paths: Vec<String> = vec![
         "another/".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion/".to_string(),
         "nushell".to_string(),
         "test_a/".to_string(),
         "test_b/".to_string(),
@@ -312,6 +447,7 @@ fn command_cp_with_globcompletion() {
     let expected_paths: Vec<String> = vec![
         "another\\".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion\\".to_string(),
         "nushell".to_string(),
         "test_a\\".to_string(),
         "test_b\\".to_string(),
@@ -322,6 +458,7 @@ fn command_cp_with_globcompletion() {
     let expected_paths: Vec<String> = vec![
         "another/".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion/".to_string(),
         "nushell".to_string(),
         "test_a/".to_string(),
         "test_b/".to_string(),
@@ -345,6 +482,7 @@ fn command_save_with_filecompletion() {
     let expected_paths: Vec<String> = vec![
         "another\\".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion\\".to_string(),
         "nushell".to_string(),
         "test_a\\".to_string(),
         "test_b\\".to_string(),
@@ -355,6 +493,7 @@ fn command_save_with_filecompletion() {
     let expected_paths: Vec<String> = vec![
         "another/".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion/".to_string(),
         "nushell".to_string(),
         "test_a/".to_string(),
         "test_b/".to_string(),
@@ -378,6 +517,7 @@ fn command_touch_with_filecompletion() {
     let expected_paths: Vec<String> = vec![
         "another\\".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion\\".to_string(),
         "nushell".to_string(),
         "test_a\\".to_string(),
         "test_b\\".to_string(),
@@ -388,6 +528,7 @@ fn command_touch_with_filecompletion() {
     let expected_paths: Vec<String> = vec![
         "another/".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion/".to_string(),
         "nushell".to_string(),
         "test_a/".to_string(),
         "test_b/".to_string(),
@@ -411,6 +552,7 @@ fn command_watch_with_filecompletion() {
     let expected_paths: Vec<String> = vec![
         "another\\".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion\\".to_string(),
         "nushell".to_string(),
         "test_a\\".to_string(),
         "test_b\\".to_string(),
@@ -421,6 +563,7 @@ fn command_watch_with_filecompletion() {
     let expected_paths: Vec<String> = vec![
         "another/".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion/".to_string(),
         "nushell".to_string(),
         "test_a/".to_string(),
         "test_b/".to_string(),
@@ -441,10 +584,26 @@ fn file_completion_quoted() {
     let suggestions = completer.complete(target_dir, target_dir.len());
 
     let expected_paths: Vec<String> = vec![
+        "`--help`".to_string(),
+        "`-42`".to_string(),
+        "`-inf`".to_string(),
+        "`4.2`".to_string(),
         "`te st.txt`".to_string(),
         "`te#st.txt`".to_string(),
         "`te'st.txt`".to_string(),
         "`te(st).txt`".to_string(),
+        format!("`{}`", folder("test dir".into())),
+    ];
+
+    match_suggestions(expected_paths, suggestions);
+
+    let dir: PathBuf = "test dir".into();
+    let target_dir = format!("open '{}'", folder(dir.clone()));
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    let expected_paths: Vec<String> = vec![
+        format!("`{}`", file(dir.join("double quote"))),
+        format!("`{}`", file(dir.join("single quote"))),
     ];
 
     match_suggestions(expected_paths, suggestions)
@@ -500,6 +659,7 @@ fn folder_with_directorycompletions() {
     // Create the expected values
     let expected_paths: Vec<String> = vec![
         folder(dir.join("another")),
+        folder(dir.join("directory_completion")),
         folder(dir.join("test_a")),
         folder(dir.join("test_b")),
         folder(dir.join(".hidden_folder")),
@@ -538,7 +698,7 @@ fn variables_completions() {
         "loginshell-path".into(),
         "os-info".into(),
         "pid".into(),
-        "scope".into(),
+        "plugin-path".into(),
         "startup-time".into(),
         "temp-path".into(),
     ];
@@ -568,88 +728,6 @@ fn variables_completions() {
     // Match results
     match_suggestions(expected, suggestions);
 
-    // Test completions for $nu.scope
-    let suggestions = completer.complete("$nu.scope.", 10);
-    assert_eq!(5, suggestions.len());
-    let expected: Vec<String> = vec![
-        "aliases".into(),
-        "commands".into(),
-        "engine_state".into(),
-        "modules".into(),
-        "vars".into(),
-    ];
-    // Match results
-    match_suggestions(expected, suggestions);
-
-    // Test completions for $nu.scope.commands
-    let suggestions = completer.complete("$nu.scope.commands.", 19);
-    assert_eq!(15, suggestions.len());
-    let expected: Vec<String> = vec![
-        "category".into(),
-        "creates_scope".into(),
-        "examples".into(),
-        "extra_usage".into(),
-        "is_builtin".into(),
-        "is_custom".into(),
-        "is_extern".into(),
-        "is_keyword".into(),
-        "is_plugin".into(),
-        "is_sub".into(),
-        "module_name".into(),
-        "name".into(),
-        "search_terms".into(),
-        "signatures".into(),
-        "usage".into(),
-    ];
-    // Match results
-    match_suggestions(expected, suggestions);
-
-    // Test completions for $nu.scope.commands.signatures
-    let suggestions = completer.complete("$nu.scope.commands.signatures.", 30);
-    assert_eq!(17, suggestions.len());
-    let expected: Vec<String> = vec![
-        "any".into(),
-        "binary".into(),
-        "bool".into(),
-        "datetime".into(),
-        "duration".into(),
-        "filesize".into(),
-        "int".into(),
-        "list<any>".into(),
-        "list<binary>".into(),
-        "list<number>".into(),
-        "list<string>".into(),
-        "nothing".into(),
-        "number".into(),
-        "range".into(),
-        "record".into(),
-        "string".into(),
-        "table".into(),
-    ];
-    // Match results
-    match_suggestions(expected, suggestions);
-
-    // Test completions for $nu.scope.engine_state
-    let suggestions = completer.complete("$nu.scope.engine_state.", 23);
-    assert_eq!(6, suggestions.len());
-    let expected: Vec<String> = vec![
-        "num_blocks".into(),
-        "num_decls".into(),
-        "num_env_vars".into(),
-        "num_modules".into(),
-        "num_vars".into(),
-        "source_bytes".into(),
-    ];
-    // Match results
-    match_suggestions(expected, suggestions);
-
-    // Test completions for $nu.scope.vars
-    let suggestions = completer.complete("$nu.scope.vars.", 15);
-    assert_eq!(3, suggestions.len());
-    let expected: Vec<String> = vec!["name".into(), "type".into(), "value".into()];
-    // Match results
-    match_suggestions(expected, suggestions);
-
     // Test completions for custom var
     let suggestions = completer.complete("$actor.", 7);
 
@@ -775,7 +853,7 @@ fn run_external_completion(block: &str, input: &str) -> Vec<Suggestion> {
     // 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);
+    engine_state.set_config(config);
 
     // Instantiate a new completer
     let mut completer = NuCompleter::new(std::sync::Arc::new(engine_state), stack);
@@ -796,6 +874,7 @@ fn unknown_command_completion() {
     let expected_paths: Vec<String> = vec![
         "another\\".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion\\".to_string(),
         "nushell".to_string(),
         "test_a\\".to_string(),
         "test_b\\".to_string(),
@@ -806,6 +885,7 @@ fn unknown_command_completion() {
     let expected_paths: Vec<String> = vec![
         "another/".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion/".to_string(),
         "nushell".to_string(),
         "test_a/".to_string(),
         "test_b/".to_string(),
@@ -856,6 +936,7 @@ fn filecompletions_triggers_after_cursor() {
     let expected_paths: Vec<String> = vec![
         "another\\".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion\\".to_string(),
         "nushell".to_string(),
         "test_a\\".to_string(),
         "test_b\\".to_string(),
@@ -866,6 +947,7 @@ fn filecompletions_triggers_after_cursor() {
     let expected_paths: Vec<String> = vec![
         "another/".to_string(),
         "custom_completion.nu".to_string(),
+        "directory_completion/".to_string(),
         "nushell".to_string(),
         "test_a/".to_string(),
         "test_b/".to_string(),
@@ -918,6 +1000,34 @@ fn extern_complete_flags(mut extern_completer: NuCompleter) {
     match_suggestions(expected, suggestions);
 }
 
+#[rstest]
+fn custom_completer_triggers_cursor_before_word(mut custom_completer: NuCompleter) {
+    let suggestions = custom_completer.complete("cmd foo  bar", 8);
+    let expected: Vec<String> = vec!["cmd".into(), "foo".into(), "".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn custom_completer_triggers_cursor_on_word_left_boundary(mut custom_completer: NuCompleter) {
+    let suggestions = custom_completer.complete("cmd foo bar", 8);
+    let expected: Vec<String> = vec!["cmd".into(), "foo".into(), "".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn custom_completer_triggers_cursor_next_to_word(mut custom_completer: NuCompleter) {
+    let suggestions = custom_completer.complete("cmd foo bar", 11);
+    let expected: Vec<String> = vec!["cmd".into(), "foo".into(), "bar".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn custom_completer_triggers_cursor_after_word(mut custom_completer: NuCompleter) {
+    let suggestions = custom_completer.complete("cmd foo bar ", 12);
+    let expected: Vec<String> = vec!["cmd".into(), "foo".into(), "bar".into(), "".into()];
+    match_suggestions(expected, suggestions);
+}
+
 #[ignore = "was reverted, still needs fixing"]
 #[rstest]
 fn alias_offset_bug_7648() {

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

@@ -1,16 +1,20 @@
 use std::path::PathBuf;
 
-use nu_command::create_default_context;
 use nu_engine::eval_block;
 use nu_parser::parse;
 use nu_protocol::{
     engine::{EngineState, Stack, StateWorkingSet},
-    PipelineData, ShellError, Span, Value,
+    eval_const::create_nu_constant,
+    PipelineData, ShellError, Span, Value, NU_VARIABLE_ID,
 };
 use nu_test_support::fs;
 use reedline::Suggestion;
 const SEP: char = std::path::MAIN_SEPARATOR;
 
+fn create_default_context() -> EngineState {
+    nu_command::add_shell_command_context(nu_cmd_lang::create_default_context())
+}
+
 // creates a new engine with the current path into the completions fixtures folder
 pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
     // Target folder inside assets
@@ -25,39 +29,41 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
     // Create a new engine with default context
     let mut engine_state = create_default_context();
 
+    // Add $nu
+    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();
 
     // Add pwd as env var
     stack.add_env_var(
         "PWD".to_string(),
-        Value::String {
-            val: dir_str.clone(),
-            span: nu_protocol::Span::new(0, dir_str.len()),
-        },
+        Value::string(dir_str.clone(), nu_protocol::Span::new(0, dir_str.len())),
     );
     stack.add_env_var(
         "TEST".to_string(),
-        Value::String {
-            val: "NUSHELL".to_string(),
-            span: nu_protocol::Span::new(0, dir_str.len()),
-        },
+        Value::string(
+            "NUSHELL".to_string(),
+            nu_protocol::Span::new(0, dir_str.len()),
+        ),
     );
     #[cfg(windows)]
     stack.add_env_var(
         "Path".to_string(),
-        Value::String {
-            val: "c:\\some\\path;c:\\some\\other\\path".to_string(),
-            span: nu_protocol::Span::new(0, dir_str.len()),
-        },
+        Value::string(
+            "c:\\some\\path;c:\\some\\other\\path".to_string(),
+            nu_protocol::Span::new(0, dir_str.len()),
+        ),
     );
     #[cfg(not(windows))]
     stack.add_env_var(
         "PATH".to_string(),
-        Value::String {
-            val: "/some/path:/some/other/path".to_string(),
-            span: nu_protocol::Span::new(0, dir_str.len()),
-        },
+        Value::string(
+            "/some/path:/some/other/path".to_string(),
+            nu_protocol::Span::new(0, dir_str.len()),
+        ),
     );
 
     // Merge environment into the permanent state
@@ -86,17 +92,50 @@ pub fn new_quote_engine() -> (PathBuf, String, EngineState, Stack) {
     // Add pwd as env var
     stack.add_env_var(
         "PWD".to_string(),
-        Value::String {
-            val: dir_str.clone(),
-            span: nu_protocol::Span::new(0, dir_str.len()),
-        },
+        Value::string(dir_str.clone(), nu_protocol::Span::new(0, dir_str.len())),
     );
     stack.add_env_var(
         "TEST".to_string(),
-        Value::String {
-            val: "NUSHELL".to_string(),
-            span: nu_protocol::Span::new(0, dir_str.len()),
-        },
+        Value::string(
+            "NUSHELL".to_string(),
+            nu_protocol::Span::new(0, dir_str.len()),
+        ),
+    );
+
+    // Merge environment into the permanent state
+    let merge_result = engine_state.merge_env(&mut stack, &dir);
+    assert!(merge_result.is_ok());
+
+    (dir, dir_str, engine_state, stack)
+}
+
+pub fn new_partial_engine() -> (PathBuf, String, EngineState, Stack) {
+    // Target folder inside assets
+    let dir = fs::fixtures().join("partial_completions");
+    let mut dir_str = dir
+        .clone()
+        .into_os_string()
+        .into_string()
+        .unwrap_or_default();
+    dir_str.push(SEP);
+
+    // Create a new engine with default context
+    let mut engine_state = create_default_context();
+
+    // New stack
+    let mut stack = Stack::new();
+
+    // Add pwd as env var
+    stack.add_env_var(
+        "PWD".to_string(),
+        Value::string(dir_str.clone(), nu_protocol::Span::new(0, dir_str.len())),
+    );
+    stack.add_env_var(
+        "TEST".to_string(),
+        Value::string(
+            "NUSHELL".to_string(),
+            nu_protocol::Span::new(0, dir_str.len()),
+        ),
     );
 
     // Merge environment into the permanent state
@@ -159,12 +198,7 @@ pub fn merge_input(
         engine_state,
         stack,
         &block,
-        PipelineData::Value(
-            Value::Nothing {
-                span: Span::unknown(),
-            },
-            None
-        ),
+        PipelineData::Value(Value::nothing(Span::unknown(),), None),
         false,
         false
     )

crates/nu-cmd-base/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+authors = ["The Nushell Project Developers"]
+description = "The foundation tools to build Nushell commands."
+edition = "2021"
+license = "MIT"
+name = "nu-cmd-base"
+repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cmd-base"
+version = "0.88.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.88.2" }
+nu-glob = { path = "../nu-glob", version = "0.88.2" }
+nu-parser = { path = "../nu-parser", version = "0.88.2" }
+nu-path = { path = "../nu-path", version = "0.88.2" }
+nu-protocol = { path = "../nu-protocol", version = "0.88.2" }
+nu-utils = { path = "../nu-utils", version = "0.88.2" }
+
+indexmap = "2.1"
+miette = "5.10.0"
+
+[dev-dependencies]
+nu-test-support = { path = "../nu-test-support", version = "0.88.2" }
+rstest = "0.18.2"

crates/nu-cmd-base/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 - 2023 The Nushell Project Developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,205 @@
+// utilities for expanding globs in command arguments
+
+use nu_glob::{glob_with_parent, MatchOptions, Paths};
+use nu_protocol::{ShellError, Spanned};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+// standard glob options to use for filesystem command arguments
+
+const GLOB_PARAMS: MatchOptions = MatchOptions {
+    case_sensitive: true,
+    require_literal_separator: false,
+    require_literal_leading_dot: false,
+    recursive_match_hidden_dir: true,
+};
+
+// handle an argument that could be a literal path or a glob.
+// if literal path, return just that (whether user can access it or not).
+// if glob, expand into matching paths, using GLOB_PARAMS options.
+pub fn arg_glob(
+    pattern: &Spanned<String>, // alleged path or glob
+    cwd: &Path,                // current working directory
+) -> Result<Paths, ShellError> {
+    arg_glob_opt(pattern, cwd, GLOB_PARAMS)
+}
+
+// variant of [arg_glob] that requires literal dot prefix in pattern to match dot-prefixed path.
+pub fn arg_glob_leading_dot(pattern: &Spanned<String>, cwd: &Path) -> Result<Paths, ShellError> {
+    arg_glob_opt(
+        pattern,
+        cwd,
+        MatchOptions {
+            require_literal_leading_dot: true,
+            ..GLOB_PARAMS
+        },
+    )
+}
+
+fn arg_glob_opt(
+    pattern: &Spanned<String>,
+    cwd: &Path,
+    options: MatchOptions,
+) -> Result<Paths, ShellError> {
+    // remove ansi coloring (?)
+    let pattern = {
+        Spanned {
+            item: nu_utils::strip_ansi_string_unlikely(pattern.item.clone()),
+            span: pattern.span,
+        }
+    };
+
+    // if there's a file with same path as the pattern, just return that.
+    let pp = cwd.join(&pattern.item);
+    let md = fs::metadata(pp);
+    #[allow(clippy::single_match)]
+    match md {
+        Ok(_metadata) => {
+            return Ok(Paths::single(&PathBuf::from(pattern.item), cwd));
+        }
+        // file not found, but also "invalid chars in file" (e.g * on Windows).  Fall through and glob
+        Err(_) => {}
+    }
+
+    // user wasn't referring to a specific thing in filesystem, try to glob it.
+    match glob_with_parent(&pattern.item, options, cwd) {
+        Ok(p) => Ok(p),
+        Err(pat_err) => Err(ShellError::InvalidGlobPattern {
+            msg: pat_err.msg.into(),
+            span: pattern.span,
+        }),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use nu_glob::GlobResult;
+    use nu_protocol::{Span, Spanned};
+    use nu_test_support::fs::Stub::EmptyFile;
+    use nu_test_support::playground::Playground;
+    use rstest::rstest;
+
+    fn spanned_string(str: &str) -> Spanned<String> {
+        Spanned {
+            item: str.to_string(),
+            span: Span::test_data(),
+        }
+    }
+
+    #[test]
+    fn does_something() {
+        let act = arg_glob(&spanned_string("*"), &PathBuf::from("."));
+        assert!(act.is_ok());
+        for f in act.expect("checked ok") {
+            match f {
+                Ok(p) => {
+                    assert!(!p.to_str().unwrap().is_empty());
+                }
+                Err(e) => panic!("unexpected error {:?}", e),
+            };
+        }
+    }
+
+    #[test]
+    fn glob_format_error() {
+        let act = arg_glob(&spanned_string(r#"ab]c[def"#), &PathBuf::from("."));
+        assert!(act.is_err());
+    }
+
+    #[rstest]
+    #[case("*", 4, "no dirs")]
+    #[case("**/*", 7, "incl dirs")]
+    fn glob_subdirs(#[case] pat: &str, #[case] exp_count: usize, #[case] case: &str) {
+        Playground::setup("glob_subdirs", |dirs, sandbox| {
+            sandbox.with_files(vec![
+                EmptyFile("yehuda.txt"),
+                EmptyFile("jttxt"),
+                EmptyFile("andres.txt"),
+            ]);
+            sandbox.mkdir(".children");
+            sandbox.within(".children").with_files(vec![
+                EmptyFile("timothy.txt"),
+                EmptyFile("tiffany.txt"),
+                EmptyFile("trish.txt"),
+            ]);
+
+            let p: Vec<GlobResult> = arg_glob(&spanned_string(pat), &dirs.test)
+                .expect("no error")
+                .collect();
+            assert_eq!(
+                exp_count,
+                p.iter().filter(|i| i.is_ok()).count(),
+                " case: {case} ",
+            );
+
+            // expected behavior -- that directories are included in results (if name matches pattern)
+            let t = p
+                .iter()
+                .any(|i| i.as_ref().unwrap().to_string_lossy().contains(".children"));
+            assert!(t, "check for dir, case {case}");
+        })
+    }
+
+    #[rstest]
+    #[case("yehuda.txt", true, 1, "matches literal path")]
+    #[case("*", false, 3, "matches glob")]
+    #[case(r#"bad[glob.foo"#, true, 1, "matches literal, would be bad glob pat")]
+    fn exact_vs_glob(
+        #[case] pat: &str,
+        #[case] exp_matches_input: bool,
+        #[case] exp_count: usize,
+        #[case] case: &str,
+    ) {
+        Playground::setup("exact_vs_glob", |dirs, sandbox| {
+            sandbox.with_files(vec![
+                EmptyFile("yehuda.txt"),
+                EmptyFile("jttxt"),
+                EmptyFile("bad[glob.foo"),
+            ]);
+
+            let res = arg_glob(&spanned_string(pat), &dirs.test)
+                .expect("no error")
+                .collect::<Vec<GlobResult>>();
+
+            eprintln!("res: {:?}", res);
+            if exp_matches_input {
+                assert_eq!(
+                    exp_count,
+                    res.len(),
+                    " case {case}: matches input, but count not 1? "
+                );
+                assert_eq!(
+                    &res[0].as_ref().unwrap().to_string_lossy(),
+                    pat, // todo: is it OK for glob to return relative paths (not to current cwd, but to arg cwd of arg_glob)?
+                );
+            } else {
+                assert_eq!(exp_count, res.len(), " case: {}: matched glob", case);
+            }
+        })
+    }
+
+    #[rstest]
+    #[case(r#"realbad[glob.foo"#, true, 1, "error, bad glob")]
+    fn exact_vs_bad_glob(
+        // if path doesn't exist but pattern is not valid glob, should get error.
+        #[case] pat: &str,
+        #[case] _exp_matches_input: bool,
+        #[case] _exp_count: usize,
+        #[case] _tag: &str,
+    ) {
+        Playground::setup("exact_vs_bad_glob", |dirs, sandbox| {
+            sandbox.with_files(vec![
+                EmptyFile("yehuda.txt"),
+                EmptyFile("jttxt"),
+                EmptyFile("bad[glob.foo"),
+            ]);
+
+            let res = arg_glob(&spanned_string(pat), &dirs.test);
+            assert!(res
+                .expect_err("expected error")
+                .to_string()
+                .contains("Invalid glob pattern"));
+        })
+    }
+}

crates/nu-cmd-base/src/formats/mod.rs

@@ -0,0 +1 @@
+pub mod to;

crates/nu-cmd-base/src/formats/to/delimited.rs

@@ -0,0 +1,20 @@
+use indexmap::{indexset, IndexSet};
+use nu_protocol::Value;
+
+pub fn merge_descriptors(values: &[Value]) -> Vec<String> {
+    let mut ret: Vec<String> = vec![];
+    let mut seen: IndexSet<String> = indexset! {};
+    for value in values {
+        let data_descriptors = match value {
+            Value::Record { val, .. } => val.columns().cloned().collect(),
+            _ => vec!["".to_string()],
+        };
+        for desc in data_descriptors {
+            if !desc.is_empty() && !seen.contains(&desc) {
+                seen.insert(desc.to_string());
+                ret.push(desc.to_string());
+            }
+        }
+    }
+    ret
+}

crates/nu-cmd-base/src/formats/to/mod.rs

@@ -0,0 +1 @@
+pub mod delimited;

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

@@ -0,0 +1,362 @@
+use crate::util::get_guaranteed_cwd;
+use miette::Result;
+use nu_engine::{eval_block, eval_block_with_early_return};
+use nu_parser::parse;
+use nu_protocol::cli_error::{report_error, report_error_new};
+use nu_protocol::engine::{EngineState, Stack, StateWorkingSet};
+use nu_protocol::{BlockId, PipelineData, PositionalArg, ShellError, Span, Type, Value, VarId};
+
+pub fn eval_env_change_hook(
+    env_change_hook: Option<Value>,
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+) -> Result<(), ShellError> {
+    if let Some(hook) = env_change_hook {
+        match hook {
+            Value::Record { val, .. } => {
+                for (env_name, hook_value) in &val {
+                    let before = engine_state
+                        .previous_env_vars
+                        .get(env_name)
+                        .cloned()
+                        .unwrap_or_default();
+
+                    let after = stack
+                        .get_env_var(engine_state, env_name)
+                        .unwrap_or_default();
+
+                    if before != after {
+                        eval_hook(
+                            engine_state,
+                            stack,
+                            None,
+                            vec![("$before".into(), before), ("$after".into(), after.clone())],
+                            hook_value,
+                            "env_change",
+                        )?;
+
+                        engine_state
+                            .previous_env_vars
+                            .insert(env_name.to_string(), after);
+                    }
+                }
+            }
+            x => {
+                return Err(ShellError::TypeMismatch {
+                    err_message: "record for the 'env_change' hook".to_string(),
+                    span: x.span(),
+                });
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub fn eval_hook(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    input: Option<PipelineData>,
+    arguments: Vec<(String, Value)>,
+    value: &Value,
+    hook_name: &str,
+) -> Result<PipelineData, ShellError> {
+    let mut output = PipelineData::empty();
+
+    let span = value.span();
+    match value {
+        Value::String { val, .. } => {
+            let (block, delta, vars) = {
+                let mut working_set = StateWorkingSet::new(engine_state);
+
+                let mut vars: Vec<(VarId, Value)> = vec![];
+
+                for (name, val) in arguments {
+                    let var_id = working_set.add_variable(
+                        name.as_bytes().to_vec(),
+                        val.span(),
+                        Type::Any,
+                        false,
+                    );
+                    vars.push((var_id, val));
+                }
+
+                let output = parse(
+                    &mut working_set,
+                    Some(&format!("{hook_name} hook")),
+                    val.as_bytes(),
+                    false,
+                );
+                if let Some(err) = working_set.parse_errors.first() {
+                    report_error(&working_set, err);
+
+                    return Err(ShellError::UnsupportedConfigValue {
+                        expected: "valid source code".into(),
+                        value: "source code with syntax errors".into(),
+                        span,
+                    });
+                }
+
+                (output, working_set.render(), vars)
+            };
+
+            engine_state.merge_delta(delta)?;
+            let input = if let Some(input) = input {
+                input
+            } else {
+                PipelineData::empty()
+            };
+
+            let var_ids: Vec<VarId> = vars
+                .into_iter()
+                .map(|(var_id, val)| {
+                    stack.add_var(var_id, val);
+                    var_id
+                })
+                .collect();
+
+            match eval_block(engine_state, stack, &block, input, false, false) {
+                Ok(pipeline_data) => {
+                    output = pipeline_data;
+                }
+                Err(err) => {
+                    report_error_new(engine_state, &err);
+                }
+            }
+
+            for var_id in var_ids.iter() {
+                stack.remove_var(*var_id);
+            }
+        }
+        Value::List { vals, .. } => {
+            for val in vals {
+                eval_hook(
+                    engine_state,
+                    stack,
+                    None,
+                    arguments.clone(),
+                    val,
+                    &format!("{hook_name} list, recursive"),
+                )?;
+            }
+        }
+        Value::Record { val, .. } => {
+            // Hooks can optionally be a record in this form:
+            // {
+            //     condition: {|before, after| ... }  # block that evaluates to true/false
+            //     code: # block or a string
+            // }
+            // The condition block will be run to check whether the main hook (in `code`) should be run.
+            // 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(block_id) = condition.as_block() {
+                    match run_hook_block(
+                        engine_state,
+                        stack,
+                        block_id,
+                        None,
+                        arguments.clone(),
+                        other_span,
+                    ) {
+                        Ok(pipeline_data) => {
+                            if let PipelineData::Value(Value::Bool { val, .. }, ..) = pipeline_data
+                            {
+                                val
+                            } else {
+                                return Err(ShellError::UnsupportedConfigValue {
+                                    expected: "boolean output".to_string(),
+                                    value: "other PipelineData variant".to_string(),
+                                    span: other_span,
+                                });
+                            }
+                        }
+                        Err(err) => {
+                            return Err(err);
+                        }
+                    }
+                } else {
+                    return Err(ShellError::UnsupportedConfigValue {
+                        expected: "block".to_string(),
+                        value: format!("{}", condition.get_type()),
+                        span: other_span,
+                    });
+                }
+            } else {
+                // always run the hook
+                true
+            };
+
+            if do_run_hook {
+                let Some(follow) = val.get("code") else {
+                    return Err(ShellError::CantFindColumn {
+                        col_name: "code".into(),
+                        span,
+                        src_span: span,
+                    });
+                };
+                let source_span = follow.span();
+                match follow {
+                    Value::String { val, .. } => {
+                        let (block, delta, vars) = {
+                            let mut working_set = StateWorkingSet::new(engine_state);
+
+                            let mut vars: Vec<(VarId, Value)> = vec![];
+
+                            for (name, val) in arguments {
+                                let var_id = working_set.add_variable(
+                                    name.as_bytes().to_vec(),
+                                    val.span(),
+                                    Type::Any,
+                                    false,
+                                );
+                                vars.push((var_id, val));
+                            }
+
+                            let output = parse(
+                                &mut working_set,
+                                Some(&format!("{hook_name} hook")),
+                                val.as_bytes(),
+                                false,
+                            );
+                            if let Some(err) = working_set.parse_errors.first() {
+                                report_error(&working_set, err);
+
+                                return Err(ShellError::UnsupportedConfigValue {
+                                    expected: "valid source code".into(),
+                                    value: "source code with syntax errors".into(),
+                                    span: source_span,
+                                });
+                            }
+
+                            (output, working_set.render(), vars)
+                        };
+
+                        engine_state.merge_delta(delta)?;
+                        let input = PipelineData::empty();
+
+                        let var_ids: Vec<VarId> = vars
+                            .into_iter()
+                            .map(|(var_id, val)| {
+                                stack.add_var(var_id, val);
+                                var_id
+                            })
+                            .collect();
+
+                        match eval_block(engine_state, stack, &block, input, false, false) {
+                            Ok(pipeline_data) => {
+                                output = pipeline_data;
+                            }
+                            Err(err) => {
+                                report_error_new(engine_state, &err);
+                            }
+                        }
+
+                        for var_id in var_ids.iter() {
+                            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_block(
+                            engine_state,
+                            stack,
+                            val.block_id,
+                            input,
+                            arguments,
+                            source_span,
+                        )?;
+                    }
+                    other => {
+                        return Err(ShellError::UnsupportedConfigValue {
+                            expected: "block or string".to_string(),
+                            value: format!("{}", other.get_type()),
+                            span: source_span,
+                        });
+                    }
+                }
+            }
+        }
+        Value::Block { val: block_id, .. } => {
+            output = run_hook_block(engine_state, stack, *block_id, input, arguments, span)?;
+        }
+        Value::Closure { val, .. } => {
+            output = run_hook_block(engine_state, stack, val.block_id, input, arguments, span)?;
+        }
+        other => {
+            return Err(ShellError::UnsupportedConfigValue {
+                expected: "string, block, record, or list of commands".into(),
+                value: format!("{}", other.get_type()),
+                span: other.span(),
+            });
+        }
+    }
+
+    let cwd = get_guaranteed_cwd(engine_state, stack);
+    engine_state.merge_env(stack, cwd)?;
+
+    Ok(output)
+}
+
+fn run_hook_block(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    block_id: BlockId,
+    optional_input: Option<PipelineData>,
+    arguments: Vec<(String, Value)>,
+    span: Span,
+) -> Result<PipelineData, ShellError> {
+    let block = engine_state.get_block(block_id);
+
+    let input = optional_input.unwrap_or_else(PipelineData::empty);
+
+    let mut callee_stack = stack.gather_captures(engine_state, &block.captures);
+
+    for (idx, PositionalArg { var_id, .. }) in
+        block.signature.required_positional.iter().enumerate()
+    {
+        if let Some(var_id) = var_id {
+            if let Some(arg) = arguments.get(idx) {
+                callee_stack.add_var(*var_id, arg.1.clone())
+            } else {
+                return Err(ShellError::IncompatibleParametersSingle {
+                    msg: "This hook block has too many parameters".into(),
+                    span,
+                });
+            }
+        }
+    }
+
+    let pipeline_data =
+        eval_block_with_early_return(engine_state, &mut callee_stack, block, input, false, false)?;
+
+    if let PipelineData::Value(Value::Error { error, .. }, _) = pipeline_data {
+        return Err(*error);
+    }
+
+    // If all went fine, preserve the environment of the called block
+    let caller_env_vars = stack.get_env_var_names(engine_state);
+
+    // remove env vars that are present in the caller but not in the callee
+    // (the callee hid them)
+    for var in caller_env_vars.iter() {
+        if !callee_stack.has_env_var(engine_state, var) {
+            stack.remove_env_var(engine_state, var);
+        }
+    }
+
+    // add new env vars from callee to caller
+    for (var, value) in callee_stack.get_stack_env_vars() {
+        stack.add_env_var(var, value);
+    }
+    Ok(pipeline_data)
+}

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

@@ -76,9 +76,7 @@ where
                             }),
                         );
                         if let Err(error) = r {
-                            return Value::Error {
-                                error: Box::new(error),
-                            };
+                            return Value::error(error, span);
                         }
                     }
                     v

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

@@ -0,0 +1,7 @@
+mod arg_glob;
+pub mod formats;
+pub mod hook;
+pub mod input_handler;
+pub mod util;
+pub use arg_glob::arg_glob;
+pub use arg_glob::arg_glob_leading_dot;

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

@@ -0,0 +1,127 @@
+use nu_protocol::report_error;
+use nu_protocol::{
+    ast::RangeInclusion,
+    engine::{EngineState, Stack, StateWorkingSet},
+    Range, ShellError, Span, Value,
+};
+use std::path::PathBuf;
+
+pub fn get_init_cwd() -> PathBuf {
+    std::env::current_dir().unwrap_or_else(|_| {
+        std::env::var("PWD")
+            .map(Into::into)
+            .unwrap_or_else(|_| nu_path::home_dir().unwrap_or_default())
+    })
+}
+
+pub fn get_guaranteed_cwd(engine_state: &EngineState, stack: &Stack) -> PathBuf {
+    nu_engine::env::current_dir(engine_state, stack).unwrap_or_else(|e| {
+        let working_set = StateWorkingSet::new(engine_state);
+        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> {
+    let start = match &range.from {
+        Value::Int { val, .. } => isize::try_from(*val).unwrap_or_default(),
+        Value::Nothing { .. } => 0,
+        _ => {
+            return 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. \
+For more help: (https://nushell.sh/book/configuration.html#configurations-with-built-in-commands)";
+
+fn get_editor_commandline(
+    value: &Value,
+    var_name: &str,
+) -> Result<(String, Vec<String>), ShellError> {
+    match value {
+        Value::String { val, .. } if !val.is_empty() => Ok((val.to_string(), Vec::new())),
+        Value::List { vals, .. } if !vals.is_empty() => {
+            let mut editor_cmd = vals.iter().map(|l| l.as_string());
+            match editor_cmd.next().transpose()? {
+                Some(editor) if !editor.is_empty() => {
+                    let params = editor_cmd.collect::<Result<_, ShellError>>()?;
+                    Ok((editor, params))
+                }
+                _ => Err(ShellError::GenericError {
+                    error: "Editor executable is missing".into(),
+                    msg: "Set the first element to an executable".into(),
+                    span: Some(value.span()),
+                    help: Some(HELP_MSG.into()),
+                    inner: vec![],
+                }),
+            }
+        }
+        Value::String { .. } | Value::List { .. } => Err(ShellError::GenericError {
+            error: format!("{var_name} should be a non-empty string or list<String>"),
+            msg: "Specify an executable here".into(),
+            span: Some(value.span()),
+            help: Some(HELP_MSG.into()),
+            inner: vec![],
+        }),
+        x => Err(ShellError::CantConvert {
+            to_type: "string or list<string>".into(),
+            from_type: x.get_type().to_string(),
+            span: value.span(),
+            help: None,
+        }),
+    }
+}
+
+pub fn get_editor(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    span: Span,
+) -> Result<(String, Vec<String>), ShellError> {
+    let config = engine_state.get_config();
+    let env_vars = stack.get_env_vars(engine_state);
+
+    if let Ok(buff_editor) =
+        get_editor_commandline(&config.buffer_editor, "$env.config.buffer_editor")
+    {
+        Ok(buff_editor)
+    } else if let Some(value) = env_vars.get("EDITOR") {
+        get_editor_commandline(value, "$env.EDITOR")
+    } else if let Some(value) = env_vars.get("VISUAL") {
+        get_editor_commandline(value, "$env.VISUAL")
+    } else {
+        Err(ShellError::GenericError {
+            error: "No editor configured".into(),
+            msg:
+                "Please specify one via `$env.config.buffer_editor` or `$env.EDITOR`/`$env.VISUAL`"
+                    .into(),
+            span: Some(span),
+            help: Some(HELP_MSG.into()),
+            inner: vec![],
+        })
+    }
+}

crates/nu-cmd-dataframe/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 license = "MIT"
 name = "nu-cmd-dataframe"
 repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cmd-dataframe"
-version = "0.81.0"
+version = "0.88.2"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -13,21 +13,22 @@ version = "0.81.0"
 bench = false
 
 [dependencies]
-nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.81.0" }
-nu-engine = { path = "../nu-engine", version = "0.81.0" }
-nu-parser = { path = "../nu-parser", version = "0.81.0" }
-nu-protocol = { path = "../nu-protocol", version = "0.81.0" }
+nu-engine = { path = "../nu-engine", version = "0.88.2" }
+nu-parser = { path = "../nu-parser", version = "0.88.2" }
+nu-protocol = { path = "../nu-protocol", version = "0.88.2" }
 
 # Potential dependencies for extras
-chrono = { version = "0.4", features = [
-	"std",
-	"unstable-locales",
-], default-features = false }
-fancy-regex = "0.11"
-indexmap = { version = "1.7", features = ["serde-1"] }
+chrono = { version = "0.4", features = ["std", "unstable-locales"], default-features = false }
+chrono-tz = "0.8"
+fancy-regex = "0.12"
+indexmap = { version = "2.1" }
 num = { version = "0.4", optional = true }
 serde = { version = "1.0", features = ["derive"] }
-sqlparser = { version = "0.33", features = ["serde"], optional = true }
+sqlparser = { version = "0.39", optional = true }
+polars-io = { version = "0.35", features = ["avro"], optional = true }
+polars-arrow = { version = "0.35", optional = true }
+polars-ops = { version = "0.35", optional = true }
+polars-plan = { version = "0.35", optional = true }
 
 [dependencies.polars]
 features = [
@@ -41,7 +42,11 @@ features = [
 	"dtype-categorical",
 	"dtype-datetime",
 	"dtype-struct",
-	"dynamic_groupby",
+	"dtype-i8",
+	"dtype-i16",
+	"dtype-u8",
+	"dtype-u16",
+	"dynamic_group_by",
 	"ipc",
 	"is_in",
 	"json",
@@ -54,15 +59,15 @@ features = [
 	"serde",
 	"serde-lazy",
 	"strings",
-	"strings",
 	"to_dummies",
 ]
 optional = true
-version = "0.29.0"
+version = "0.35"
 
 [features]
-dataframe = ["default"]
-default = ["num", "polars", "sqlparser"]
+dataframe = ["num", "polars", "polars-io", "polars-arrow", "polars-ops", "polars-plan", "sqlparser"]
+default = []
 
 [dev-dependencies]
-nu-test-support = { path = "../nu-test-support", version = "0.81.0" }
+nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.88.2" }
+nu-test-support = { path = "../nu-test-support", version = "0.88.2" }

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

@@ -23,8 +23,10 @@ impl Command for AppendDF {
         Signature::build(self.name())
             .required("other", SyntaxShape::Any, "dataframe to be appended")
             .switch("col", "appends in col orientation", Some('c'))
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 

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

@@ -19,8 +19,7 @@ impl Command for ColumnsDF {
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Any)
+            .input_output_type(Type::Custom("dataframe".into()), Type::Any)
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -28,10 +27,10 @@ impl Command for ColumnsDF {
         vec![Example {
             description: "Dataframe columns",
             example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr columns",
-            result: Some(Value::List {
-                vals: vec![Value::test_string("a"), Value::test_string("b")],
-                span: Span::test_data(),
-            }),
+            result: Some(Value::list(
+                vec![Value::test_string("a"), Value::test_string("b")],
+                Span::test_data(),
+            )),
         }]
     }
 
@@ -61,10 +60,7 @@ fn command(
         .map(|v| Value::string(*v, call.head))
         .collect();
 
-    let names = Value::List {
-        vals: names,
-        span: call.head,
-    };
+    let names = Value::list(names, call.head);
 
     Ok(PipelineData::Value(names, None))
 }

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

@@ -23,8 +23,10 @@ impl Command for DropDF {
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .rest("rest", SyntaxShape::Any, "column names to be dropped")
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -66,26 +68,24 @@ fn command(
     let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
     let new_df = col_string
-        .get(0)
-        .ok_or_else(|| {
-            ShellError::GenericError(
-                "Empty names list".into(),
-                "No column names were found".into(),
-                Some(col_span),
-                None,
-                Vec::new(),
-            )
+        .first()
+        .ok_or_else(|| ShellError::GenericError {
+            error: "Empty names list".into(),
+            msg: "No column names were found".into(),
+            span: Some(col_span),
+            help: None,
+            inner: vec![],
         })
         .and_then(|col| {
-            df.as_ref().drop(&col.item).map_err(|e| {
-                ShellError::GenericError(
-                    "Error dropping column".into(),
-                    e.to_string(),
-                    Some(col.span),
-                    None,
-                    Vec::new(),
-                )
-            })
+            df.as_ref()
+                .drop(&col.item)
+                .map_err(|e| ShellError::GenericError {
+                    error: "Error dropping column".into(),
+                    msg: e.to_string(),
+                    span: Some(col.span),
+                    help: None,
+                    inner: vec![],
+                })
         })?;
 
     // If there are more columns in the drop selection list, these
@@ -94,15 +94,15 @@ fn command(
         .iter()
         .skip(1)
         .try_fold(new_df, |new_df, col| {
-            new_df.drop(&col.item).map_err(|e| {
-                ShellError::GenericError(
-                    "Error dropping column".into(),
-                    e.to_string(),
-                    Some(col.span),
-                    None,
-                    Vec::new(),
-                )
-            })
+            new_df
+                .drop(&col.item)
+                .map_err(|e| ShellError::GenericError {
+                    error: "Error dropping column".into(),
+                    msg: e.to_string(),
+                    span: Some(col.span),
+                    help: None,
+                    inner: vec![],
+                })
         })
         .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
 }

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

@@ -25,7 +25,7 @@ impl Command for DropDuplicates {
         Signature::build(self.name())
             .optional(
                 "subset",
-                SyntaxShape::Table,
+                SyntaxShape::Table(vec![]),
                 "subset of columns to drop duplicates",
             )
             .switch("maintain", "maintain order", Some('m'))
@@ -34,8 +34,10 @@ impl Command for DropDuplicates {
                 "keeps last duplicate value (by default keeps first)",
                 Some('l'),
             )
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -98,14 +100,12 @@ fn command(
 
     df.as_ref()
         .unique(subset_slice, keep_strategy, None)
-        .map_err(|e| {
-            ShellError::GenericError(
-                "Error dropping duplicates".into(),
-                e.to_string(),
-                Some(col_span),
-                None,
-                Vec::new(),
-            )
+        .map_err(|e| ShellError::GenericError {
+            error: "Error dropping duplicates".into(),
+            msg: e.to_string(),
+            span: Some(col_span),
+            help: None,
+            inner: vec![],
         })
         .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
 }

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

@@ -24,11 +24,13 @@ impl Command for DropNulls {
         Signature::build(self.name())
             .optional(
                 "subset",
-                SyntaxShape::Table,
+                SyntaxShape::Table(vec![]),
                 "subset of columns to drop nulls",
             )
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -113,14 +115,12 @@ fn command(
 
     df.as_ref()
         .drop_nulls(subset_slice)
-        .map_err(|e| {
-            ShellError::GenericError(
-                "Error dropping nulls".into(),
-                e.to_string(),
-                Some(col_span),
-                None,
-                Vec::new(),
-            )
+        .map_err(|e| ShellError::GenericError {
+            error: "Error dropping nulls".into(),
+            msg: e.to_string(),
+            span: Some(col_span),
+            help: None,
+            inner: vec![],
         })
         .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
 }

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

@@ -19,8 +19,10 @@ impl Command for DataTypes {
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -77,10 +79,7 @@ fn command(
                 .dtype();
 
             let dtype_str = dtype.to_string();
-            dtypes.push(Value::String {
-                val: dtype_str,
-                span: call.head,
-            });
+            dtypes.push(Value::string(dtype_str, call.head));
 
             Value::string(*v, call.head)
         })

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

@@ -1,10 +1,10 @@
-use super::super::values::{Column, NuDataFrame};
+use super::super::values::NuDataFrame;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, Type, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, Type,
 };
-use polars::prelude::DataFrameOps;
+use polars::{prelude::*, series::Series};
 
 #[derive(Clone)]
 pub struct Dummies;
@@ -20,8 +20,11 @@ impl Command for Dummies {
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .switch("drop-first", "Drop first row", Some('d'))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -31,24 +34,15 @@ impl Command for Dummies {
                 description: "Create new dataframe with dummy variables from a dataframe",
                 example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr dummies",
                 result: Some(
-                    NuDataFrame::try_from_columns(vec![
-                        Column::new(
-                            "a_1".to_string(),
-                            vec![Value::test_int(1), Value::test_int(0)],
-                        ),
-                        Column::new(
-                            "a_3".to_string(),
-                            vec![Value::test_int(0), Value::test_int(1)],
-                        ),
-                        Column::new(
-                            "b_2".to_string(),
-                            vec![Value::test_int(1), Value::test_int(0)],
-                        ),
-                        Column::new(
-                            "b_4".to_string(),
-                            vec![Value::test_int(0), Value::test_int(1)],
-                        ),
-                    ])
+                    NuDataFrame::try_from_series(
+                        vec![
+                            Series::new("a_1", &[1_u8, 0]),
+                            Series::new("a_3", &[0_u8, 1]),
+                            Series::new("b_2", &[1_u8, 0]),
+                            Series::new("b_4", &[0_u8, 1]),
+                        ],
+                        Span::test_data(),
+                    )
                     .expect("simple df for test should not fail")
                     .into_value(Span::test_data()),
                 ),
@@ -57,38 +51,14 @@ impl Command for Dummies {
                 description: "Create new dataframe with dummy variables from a series",
                 example: "[1 2 2 3 3] | dfr into-df | dfr dummies",
                 result: Some(
-                    NuDataFrame::try_from_columns(vec![
-                        Column::new(
-                            "0_1".to_string(),
-                            vec![
-                                Value::test_int(1),
-                                Value::test_int(0),
-                                Value::test_int(0),
-                                Value::test_int(0),
-                                Value::test_int(0),
-                            ],
-                        ),
-                        Column::new(
-                            "0_2".to_string(),
-                            vec![
-                                Value::test_int(0),
-                                Value::test_int(1),
-                                Value::test_int(1),
-                                Value::test_int(0),
-                                Value::test_int(0),
-                            ],
-                        ),
-                        Column::new(
-                            "0_3".to_string(),
-                            vec![
-                                Value::test_int(0),
-                                Value::test_int(0),
-                                Value::test_int(0),
-                                Value::test_int(1),
-                                Value::test_int(1),
-                            ],
-                        ),
-                    ])
+                    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]),
+                            Series::new("0_3", &[0_u8, 0, 0, 1, 1]),
+                        ],
+                        Span::test_data(),
+                    )
                     .expect("simple df for test should not fail")
                     .into_value(Span::test_data()),
                 ),
@@ -113,18 +83,17 @@ fn command(
     call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
+    let drop_first: bool = call.has_flag("drop-first");
     let df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
     df.as_ref()
-        .to_dummies(None)
-        .map_err(|e| {
-            ShellError::GenericError(
-                "Error calculating dummies".into(),
-                e.to_string(),
-                Some(call.head),
-                Some("The only allowed column types for dummies are String or Int".into()),
-                Vec::new(),
-            )
+        .to_dummies(None, drop_first)
+        .map_err(|e| ShellError::GenericError {
+            error: "Error calculating dummies".into(),
+            msg: e.to_string(),
+            span: Some(call.head),
+            help: Some("The only allowed column types for dummies are String or Int".into()),
+            inner: vec![],
         })
         .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
 }

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

@@ -29,8 +29,10 @@ impl Command for FilterWith {
                 SyntaxShape::Any,
                 "boolean mask used to filter data",
             )
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe or lazyframe".into()))
     }
 
@@ -90,7 +92,7 @@ fn command_eager(
     df: NuDataFrame,
 ) -> Result<PipelineData, ShellError> {
     let mask_value: Value = call.req(engine_state, stack, 0)?;
-    let mask_span = mask_value.span()?;
+    let mask_span = mask_value.span();
 
     if NuExpression::can_downcast(&mask_value) {
         let expression = NuExpression::try_from_value(mask_value)?;
@@ -103,26 +105,22 @@ fn command_eager(
         ))
     } else {
         let mask = NuDataFrame::try_from_value(mask_value)?.as_series(mask_span)?;
-        let mask = mask.bool().map_err(|e| {
-            ShellError::GenericError(
-                "Error casting to bool".into(),
-                e.to_string(),
-                Some(mask_span),
-                Some("Perhaps you want to use a series with booleans as mask".into()),
-                Vec::new(),
-            )
+        let mask = mask.bool().map_err(|e| ShellError::GenericError {
+            error: "Error casting to bool".into(),
+            msg: e.to_string(),
+            span: Some(mask_span),
+            help: Some("Perhaps you want to use a series with booleans as mask".into()),
+            inner: vec![],
         })?;
 
         df.as_ref()
             .filter(mask)
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "Error filtering dataframe".into(),
-                    e.to_string(),
-                    Some(call.head),
-                    Some("The only allowed column types for dummies are String or Int".into()),
-                    Vec::new(),
-                )
+            .map_err(|e| ShellError::GenericError {
+                error: "Error filtering dataframe".into(),
+                msg: e.to_string(),
+                span: Some(call.head),
+                help: Some("The only allowed column types for dummies are String or Int".into()),
+                inner: vec![],
             })
             .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
     }

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

@@ -1,4 +1,4 @@
-use super::super::values::{Column, NuDataFrame};
+use super::super::values::{Column, NuDataFrame, NuExpression};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::Call,
@@ -15,7 +15,7 @@ impl Command for FirstDF {
     }
 
     fn usage(&self) -> &str {
-        "Show only the first number of rows."
+        "Show only the first number of rows or create a first expression"
     }
 
     fn signature(&self) -> Signature {
@@ -25,8 +25,16 @@ impl Command for FirstDF {
                 SyntaxShape::Int,
                 "starting from the front, the number of rows to return",
             )
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_types(vec![
+                (
+                    Type::Custom("expression".into()),
+                    Type::Custom("expression".into()),
+                ),
+                (
+                    Type::Custom("dataframe".into()),
+                    Type::Custom("dataframe".into()),
+                ),
+            ])
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -62,6 +70,11 @@ impl Command for FirstDF {
                     .into_value(Span::test_data()),
                 ),
             },
+            Example {
+                description: "Creates a first expression from a column",
+                example: "dfr col a | dfr first",
+                result: None,
+            },
         ]
     }
 
@@ -72,8 +85,19 @@ impl Command for FirstDF {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let df = NuDataFrame::try_from_pipeline(input, call.head)?;
-        command(engine_state, stack, call, df)
+        let value = input.into_value(call.head);
+        if NuDataFrame::can_downcast(&value) {
+            let df = NuDataFrame::try_from_value(value)?;
+            command(engine_state, stack, call, df)
+        } else {
+            let expr = NuExpression::try_from_value(value)?;
+            let expr: NuExpression = expr.into_polars().first().into();
+
+            Ok(PipelineData::Value(
+                NuExpression::into_value(expr, call.head),
+                None,
+            ))
+        }
     }
 }
 
@@ -95,11 +119,25 @@ fn command(
 
 #[cfg(test)]
 mod test {
-    use super::super::super::test_dataframe::test_dataframe;
+    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() {
-        test_dataframe(vec![Box::new(FirstDF {})])
+    fn test_examples_dataframe() {
+        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

@@ -24,8 +24,10 @@ impl Command for GetDF {
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .rest("rest", SyntaxShape::Any, "column names to sort dataframe")
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -68,14 +70,12 @@ fn command(
 
     df.as_ref()
         .select(col_string)
-        .map_err(|e| {
-            ShellError::GenericError(
-                "Error selecting columns".into(),
-                e.to_string(),
-                Some(col_span),
-                None,
-                Vec::new(),
-            )
+        .map_err(|e| ShellError::GenericError {
+            error: "Error selecting columns".into(),
+            msg: e.to_string(),
+            span: Some(col_span),
+            help: None,
+            inner: vec![],
         })
         .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
 }

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

@@ -1,4 +1,4 @@
-use super::super::values::{utils::DEFAULT_ROWS, Column, NuDataFrame};
+use super::super::values::{utils::DEFAULT_ROWS, Column, NuDataFrame, NuExpression};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::Call,
@@ -21,24 +21,39 @@ impl Command for LastDF {
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .optional("rows", SyntaxShape::Int, "Number of rows for tail")
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_types(vec![
+                (
+                    Type::Custom("expression".into()),
+                    Type::Custom("expression".into()),
+                ),
+                (
+                    Type::Custom("dataframe".into()),
+                    Type::Custom("dataframe".into()),
+                ),
+            ])
             .category(Category::Custom("dataframe".into()))
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Create new dataframe with last rows",
-            example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr last 1",
-            result: Some(
-                NuDataFrame::try_from_columns(vec![
-                    Column::new("a".to_string(), vec![Value::test_int(3)]),
-                    Column::new("b".to_string(), vec![Value::test_int(4)]),
-                ])
-                .expect("simple df for test should not fail")
-                .into_value(Span::test_data()),
-            ),
-        }]
+        vec![
+            Example {
+                description: "Create new dataframe with last rows",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr last 1",
+                result: Some(
+                    NuDataFrame::try_from_columns(vec![
+                        Column::new("a".to_string(), vec![Value::test_int(3)]),
+                        Column::new("b".to_string(), vec![Value::test_int(4)]),
+                    ])
+                    .expect("simple df for test should not fail")
+                    .into_value(Span::test_data()),
+                ),
+            },
+            Example {
+                description: "Creates a last expression from a column",
+                example: "dfr col a | dfr last",
+                result: None,
+            },
+        ]
     }
 
     fn run(
@@ -48,8 +63,19 @@ impl Command for LastDF {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let df = NuDataFrame::try_from_pipeline(input, call.head)?;
-        command(engine_state, stack, call, df)
+        let value = input.into_value(call.head);
+        if NuDataFrame::can_downcast(&value) {
+            let df = NuDataFrame::try_from_value(value)?;
+            command(engine_state, stack, call, df)
+        } else {
+            let expr = NuExpression::try_from_value(value)?;
+            let expr: NuExpression = expr.into_polars().last().into();
+
+            Ok(PipelineData::Value(
+                NuExpression::into_value(expr, call.head),
+                None,
+            ))
+        }
     }
 }
 
@@ -71,11 +97,24 @@ fn command(
 
 #[cfg(test)]
 mod test {
-    use super::super::super::test_dataframe::test_dataframe;
+    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() {
-        test_dataframe(vec![Box::new(LastDF {})])
+    fn test_examples_dataframe() {
+        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

@@ -1,7 +1,7 @@
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Value,
+    record, Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Value,
 };
 
 use crate::dataframe::values::NuDataFrame;
@@ -55,34 +55,18 @@ impl Command for ListDF {
                 NuDataFrame::try_from_value(value).ok().map(|df| (name, df))
             })
             .map(|(name, df)| {
-                let name = Value::String {
-                    val: name,
-                    span: call.head,
-                };
-
-                let columns = Value::int(df.as_ref().width() as i64, call.head);
-
-                let rows = Value::int(df.as_ref().height() as i64, call.head);
-
-                let cols = vec![
-                    "name".to_string(),
-                    "columns".to_string(),
-                    "rows".to_string(),
-                ];
-                let vals = vec![name, columns, rows];
-
-                Value::Record {
-                    cols,
-                    vals,
-                    span: call.head,
-                }
+                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,
-            span: call.head,
-        };
+        let list = Value::list(vals, call.head);
 
         Ok(list.into_pipeline_data())
     }

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

@@ -26,13 +26,13 @@ impl Command for MeltDF {
         Signature::build(self.name())
             .required_named(
                 "columns",
-                SyntaxShape::Table,
+                SyntaxShape::Table(vec![]),
                 "column names for melting",
                 Some('c'),
             )
             .required_named(
                 "values",
-                SyntaxShape::Table,
+                SyntaxShape::Table(vec![]),
                 "column names used as value columns",
                 Some('v'),
             )
@@ -48,8 +48,10 @@ impl Command for MeltDF {
                 "optional name for value column",
                 Some('l'),
             )
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -150,38 +152,34 @@ fn command(
     let mut res = df
         .as_ref()
         .melt(&id_col_string, &val_col_string)
-        .map_err(|e| {
-            ShellError::GenericError(
-                "Error calculating melt".into(),
-                e.to_string(),
-                Some(call.head),
-                None,
-                Vec::new(),
-            )
+        .map_err(|e| ShellError::GenericError {
+            error: "Error calculating melt".into(),
+            msg: e.to_string(),
+            span: Some(call.head),
+            help: None,
+            inner: vec![],
         })?;
 
     if let Some(name) = &variable_name {
-        res.rename("variable", &name.item).map_err(|e| {
-            ShellError::GenericError(
-                "Error renaming column".into(),
-                e.to_string(),
-                Some(name.span),
-                None,
-                Vec::new(),
-            )
-        })?;
+        res.rename("variable", &name.item)
+            .map_err(|e| ShellError::GenericError {
+                error: "Error renaming column".into(),
+                msg: e.to_string(),
+                span: Some(name.span),
+                help: None,
+                inner: vec![],
+            })?;
     }
 
     if let Some(name) = &value_name {
-        res.rename("value", &name.item).map_err(|e| {
-            ShellError::GenericError(
-                "Error renaming column".into(),
-                e.to_string(),
-                Some(name.span),
-                None,
-                Vec::new(),
-            )
-        })?;
+        res.rename("value", &name.item)
+            .map_err(|e| ShellError::GenericError {
+                error: "Error renaming column".into(),
+                msg: e.to_string(),
+                span: Some(name.span),
+                help: None,
+                inner: vec![],
+            })?;
     }
 
     Ok(PipelineData::Value(
@@ -196,50 +194,50 @@ fn check_column_datatypes<T: AsRef<str>>(
     col_span: Span,
 ) -> Result<(), ShellError> {
     if cols.is_empty() {
-        return Err(ShellError::GenericError(
-            "Merge error".into(),
-            "empty column list".into(),
-            Some(col_span),
-            None,
-            Vec::new(),
-        ));
+        return Err(ShellError::GenericError {
+            error: "Merge error".into(),
+            msg: "empty column list".into(),
+            span: Some(col_span),
+            help: None,
+            inner: vec![],
+        });
     }
 
     // Checking if they are same type
     if cols.len() > 1 {
         for w in cols.windows(2) {
-            let l_series = df.column(w[0].as_ref()).map_err(|e| {
-                ShellError::GenericError(
-                    "Error selecting columns".into(),
-                    e.to_string(),
-                    Some(col_span),
-                    None,
-                    Vec::new(),
-                )
-            })?;
+            let l_series = df
+                .column(w[0].as_ref())
+                .map_err(|e| ShellError::GenericError {
+                    error: "Error selecting columns".into(),
+                    msg: e.to_string(),
+                    span: Some(col_span),
+                    help: None,
+                    inner: vec![],
+                })?;
 
-            let r_series = df.column(w[1].as_ref()).map_err(|e| {
-                ShellError::GenericError(
-                    "Error selecting columns".into(),
-                    e.to_string(),
-                    Some(col_span),
-                    None,
-                    Vec::new(),
-                )
-            })?;
+            let r_series = df
+                .column(w[1].as_ref())
+                .map_err(|e| ShellError::GenericError {
+                    error: "Error selecting columns".into(),
+                    msg: e.to_string(),
+                    span: Some(col_span),
+                    help: None,
+                    inner: vec![],
+                })?;
 
             if l_series.dtype() != r_series.dtype() {
-                return Err(ShellError::GenericError(
-                    "Merge error".into(),
-                    "found different column types in list".into(),
-                    Some(col_span),
-                    Some(format!(
+                return Err(ShellError::GenericError {
+                    error: "Merge error".into(),
+                    msg: "found different column types in list".into(),
+                    span: Some(col_span),
+                    help: Some(format!(
                         "datatypes {} and {} are incompatible",
                         l_series.dtype(),
                         r_series.dtype()
                     )),
-                    Vec::new(),
-                ));
+                    inner: vec![],
+                });
             }
         }
     }

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

@@ -22,6 +22,7 @@ mod sql_expr;
 mod summary;
 mod take;
 mod to_arrow;
+mod to_avro;
 mod to_csv;
 mod to_df;
 mod to_json_lines;
@@ -55,6 +56,7 @@ pub use sql_expr::parse_sql_expr;
 pub use summary::Summary;
 pub use take::TakeDF;
 pub use to_arrow::ToArrow;
+pub use to_avro::ToAvro;
 pub use to_csv::ToCSV;
 pub use to_df::ToDataFrame;
 pub use to_json_lines::ToJsonLines;
@@ -96,6 +98,7 @@ pub fn add_eager_decls(working_set: &mut StateWorkingSet) {
         SliceDF,
         TakeDF,
         ToArrow,
+        ToAvro,
         ToCSV,
         ToDataFrame,
         ToNu,

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

@@ -13,6 +13,8 @@ use polars::prelude::{
     LazyFrame, ParallelStrategy, ParquetReader, ScanArgsIpc, ScanArgsParquet, SerReader,
 };
 
+use polars_io::avro::AvroReader;
+
 #[derive(Clone)]
 pub struct OpenDataFrame;
 
@@ -22,7 +24,7 @@ impl Command for OpenDataFrame {
     }
 
     fn usage(&self) -> &str {
-        "Opens CSV, JSON, JSON lines, arrow, or parquet file to create dataframe."
+        "Opens CSV, JSON, JSON lines, arrow, avro, or parquet file to create dataframe."
     }
 
     fn signature(&self) -> Signature {
@@ -36,7 +38,7 @@ impl Command for OpenDataFrame {
             .named(
                 "type",
                 SyntaxShape::String,
-                "File type: csv, tsv, json, parquet, arrow. If omitted, derive from file extension",
+                "File type: csv, tsv, json, parquet, arrow, avro. If omitted, derive from file extension",
                 Some('t'),
             )
             .named(
@@ -68,8 +70,7 @@ impl Command for OpenDataFrame {
                 "Columns to be selected from csv file. CSV and Parquet file",
                 None,
             )
-            .input_type(Type::Any)
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(Type::Any, Type::Custom("dataframe".into()))
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -115,19 +116,20 @@ fn command(
     match type_id {
         Some((e, msg, blamed)) => match e.as_str() {
             "csv" | "tsv" => from_csv(engine_state, stack, call),
-            "parquet" => from_parquet(engine_state, stack, call),
+            "parquet" | "parq" => from_parquet(engine_state, stack, call),
             "ipc" | "arrow" => from_ipc(engine_state, stack, call),
             "json" => from_json(engine_state, stack, call),
             "jsonl" => from_jsonl(engine_state, stack, call),
-            _ => Err(ShellError::FileNotFoundCustom(
-                format!("{msg}. Supported values: csv, tsv, parquet, ipc, arrow, json"),
-                blamed,
-            )),
+            "avro" => from_avro(engine_state, stack, call),
+            _ => Err(ShellError::FileNotFoundCustom {
+                msg: format!("{msg}. Supported values: csv, tsv, parquet, ipc, arrow, json"),
+                span: blamed,
+            }),
         },
-        None => Err(ShellError::FileNotFoundCustom(
-            "File without extension".into(),
-            file.span,
-        )),
+        None => Err(ShellError::FileNotFoundCustom {
+            msg: "File without extension".into(),
+            span: file.span,
+        }),
     }
     .map(|value| PipelineData::Value(value, None))
 }
@@ -148,17 +150,16 @@ fn from_parquet(
             low_memory: false,
             cloud_options: None,
             use_statistics: false,
+            hive_partitioning: false,
         };
 
         let df: NuLazyFrame = LazyFrame::scan_parquet(file, args)
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "Parquet reader error".into(),
-                    format!("{e:?}"),
-                    Some(call.head),
-                    None,
-                    Vec::new(),
-                )
+            .map_err(|e| ShellError::GenericError {
+                error: "Parquet reader error".into(),
+                msg: format!("{e:?}"),
+                span: Some(call.head),
+                help: None,
+                inner: vec![],
             })?
             .into();
 
@@ -167,14 +168,12 @@ fn from_parquet(
         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.item).map_err(|e| {
-            ShellError::GenericError(
-                "Error opening file".into(),
-                e.to_string(),
-                Some(file.span),
-                None,
-                Vec::new(),
-            )
+        let r = File::open(&file.item).map_err(|e| ShellError::GenericError {
+            error: "Error opening file".into(),
+            msg: e.to_string(),
+            span: Some(file.span),
+            help: None,
+            inner: vec![],
         })?;
         let reader = ParquetReader::new(r);
 
@@ -185,14 +184,12 @@ fn from_parquet(
 
         let df: NuDataFrame = reader
             .finish()
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "Parquet reader error".into(),
-                    format!("{e:?}"),
-                    Some(call.head),
-                    None,
-                    Vec::new(),
-                )
+            .map_err(|e| ShellError::GenericError {
+                error: "Parquet reader error".into(),
+                msg: format!("{e:?}"),
+                span: Some(call.head),
+                help: None,
+                inner: vec![],
             })?
             .into();
 
@@ -200,6 +197,42 @@ fn from_parquet(
     }
 }
 
+fn from_avro(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+) -> Result<Value, ShellError> {
+    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.item).map_err(|e| ShellError::GenericError {
+        error: "Error opening file".into(),
+        msg: e.to_string(),
+        span: Some(file.span),
+        help: None,
+        inner: vec![],
+    })?;
+    let reader = AvroReader::new(r);
+
+    let reader = match columns {
+        None => reader,
+        Some(columns) => reader.with_columns(Some(columns)),
+    };
+
+    let df: NuDataFrame = reader
+        .finish()
+        .map_err(|e| ShellError::GenericError {
+            error: "Avro reader error".into(),
+            msg: format!("{e:?}"),
+            span: Some(call.head),
+            help: None,
+            inner: vec![],
+        })?
+        .into();
+
+    Ok(df.into_value(call.head))
+}
+
 fn from_ipc(
     engine_state: &EngineState,
     stack: &mut Stack,
@@ -216,14 +249,12 @@ fn from_ipc(
         };
 
         let df: NuLazyFrame = LazyFrame::scan_ipc(file, args)
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "IPC reader error".into(),
-                    format!("{e:?}"),
-                    Some(call.head),
-                    None,
-                    Vec::new(),
-                )
+            .map_err(|e| ShellError::GenericError {
+                error: "IPC reader error".into(),
+                msg: format!("{e:?}"),
+                span: Some(call.head),
+                help: None,
+                inner: vec![],
             })?
             .into();
 
@@ -232,14 +263,12 @@ fn from_ipc(
         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.item).map_err(|e| {
-            ShellError::GenericError(
-                "Error opening file".into(),
-                e.to_string(),
-                Some(file.span),
-                None,
-                Vec::new(),
-            )
+        let r = File::open(&file.item).map_err(|e| ShellError::GenericError {
+            error: "Error opening file".into(),
+            msg: e.to_string(),
+            span: Some(file.span),
+            help: None,
+            inner: vec![],
         })?;
         let reader = IpcReader::new(r);
 
@@ -250,14 +279,12 @@ fn from_ipc(
 
         let df: NuDataFrame = reader
             .finish()
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "IPC reader error".into(),
-                    format!("{e:?}"),
-                    Some(call.head),
-                    None,
-                    Vec::new(),
-                )
+            .map_err(|e| ShellError::GenericError {
+                error: "IPC reader error".into(),
+                msg: format!("{e:?}"),
+                span: Some(call.head),
+                help: None,
+                inner: vec![],
             })?
             .into();
 
@@ -271,14 +298,12 @@ fn from_json(
     call: &Call,
 ) -> Result<Value, ShellError> {
     let file: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
-    let file = File::open(&file.item).map_err(|e| {
-        ShellError::GenericError(
-            "Error opening file".into(),
-            e.to_string(),
-            Some(file.span),
-            None,
-            Vec::new(),
-        )
+    let file = File::open(&file.item).map_err(|e| ShellError::GenericError {
+        error: "Error opening file".into(),
+        msg: e.to_string(),
+        span: Some(file.span),
+        help: None,
+        inner: vec![],
     })?;
 
     let buf_reader = BufReader::new(file);
@@ -286,14 +311,12 @@ fn from_json(
 
     let df: NuDataFrame = reader
         .finish()
-        .map_err(|e| {
-            ShellError::GenericError(
-                "Json reader error".into(),
-                format!("{e:?}"),
-                Some(call.head),
-                None,
-                Vec::new(),
-            )
+        .map_err(|e| ShellError::GenericError {
+            error: "Json reader error".into(),
+            msg: format!("{e:?}"),
+            span: Some(call.head),
+            help: None,
+            inner: vec![],
         })?
         .into();
 
@@ -307,14 +330,12 @@ fn from_jsonl(
 ) -> Result<Value, ShellError> {
     let infer_schema: Option<usize> = call.get_flag(engine_state, stack, "infer-schema")?;
     let file: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
-    let file = File::open(&file.item).map_err(|e| {
-        ShellError::GenericError(
-            "Error opening file".into(),
-            e.to_string(),
-            Some(file.span),
-            None,
-            Vec::new(),
-        )
+    let file = File::open(&file.item).map_err(|e| ShellError::GenericError {
+        error: "Error opening file".into(),
+        msg: e.to_string(),
+        span: Some(file.span),
+        help: None,
+        inner: vec![],
     })?;
 
     let buf_reader = BufReader::new(file);
@@ -324,14 +345,12 @@ fn from_jsonl(
 
     let df: NuDataFrame = reader
         .finish()
-        .map_err(|e| {
-            ShellError::GenericError(
-                "Json lines reader error".into(),
-                format!("{e:?}"),
-                Some(call.head),
-                None,
-                Vec::new(),
-            )
+        .map_err(|e| ShellError::GenericError {
+            error: "Json lines reader error".into(),
+            msg: format!("{e:?}"),
+            span: Some(call.head),
+            help: None,
+            inner: vec![],
         })?
         .into();
 
@@ -357,19 +376,19 @@ fn from_csv(
             None => csv_reader,
             Some(d) => {
                 if d.item.len() != 1 {
-                    return Err(ShellError::GenericError(
-                        "Incorrect delimiter".into(),
-                        "Delimiter has to be one character".into(),
-                        Some(d.span),
-                        None,
-                        Vec::new(),
-                    ));
+                    return Err(ShellError::GenericError {
+                        error: "Incorrect delimiter".into(),
+                        msg: "Delimiter has to be one character".into(),
+                        span: Some(d.span),
+                        help: None,
+                        inner: vec![],
+                    });
                 } else {
                     let delimiter = match d.item.chars().next() {
                         Some(d) => d as u8,
                         None => unreachable!(),
                     };
-                    csv_reader.with_delimiter(delimiter)
+                    csv_reader.with_separator(delimiter)
                 }
             }
         };
@@ -388,14 +407,12 @@ fn from_csv(
 
         let df: NuLazyFrame = csv_reader
             .finish()
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "Parquet reader error".into(),
-                    format!("{e:?}"),
-                    Some(call.head),
-                    None,
-                    Vec::new(),
-                )
+            .map_err(|e| ShellError::GenericError {
+                error: "Parquet reader error".into(),
+                msg: format!("{e:?}"),
+                span: Some(call.head),
+                help: None,
+                inner: vec![],
             })?
             .into();
 
@@ -403,14 +420,12 @@ fn from_csv(
     } else {
         let file: Spanned<PathBuf> = call.req(engine_state, stack, 0)?;
         let csv_reader = CsvReader::from_path(&file.item)
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "Error creating CSV reader".into(),
-                    e.to_string(),
-                    Some(file.span),
-                    None,
-                    Vec::new(),
-                )
+            .map_err(|e| ShellError::GenericError {
+                error: "Error creating CSV reader".into(),
+                msg: e.to_string(),
+                span: Some(file.span),
+                help: None,
+                inner: vec![],
             })?
             .with_encoding(CsvEncoding::LossyUtf8);
 
@@ -418,19 +433,19 @@ fn from_csv(
             None => csv_reader,
             Some(d) => {
                 if d.item.len() != 1 {
-                    return Err(ShellError::GenericError(
-                        "Incorrect delimiter".into(),
-                        "Delimiter has to be one character".into(),
-                        Some(d.span),
-                        None,
-                        Vec::new(),
-                    ));
+                    return Err(ShellError::GenericError {
+                        error: "Incorrect delimiter".into(),
+                        msg: "Delimiter has to be one character".into(),
+                        span: Some(d.span),
+                        help: None,
+                        inner: vec![],
+                    });
                 } else {
                     let delimiter = match d.item.chars().next() {
                         Some(d) => d as u8,
                         None => unreachable!(),
                     };
-                    csv_reader.with_delimiter(delimiter)
+                    csv_reader.with_separator(delimiter)
                 }
             }
         };
@@ -454,14 +469,12 @@ fn from_csv(
 
         let df: NuDataFrame = csv_reader
             .finish()
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "Parquet reader error".into(),
-                    format!("{e:?}"),
-                    Some(call.head),
-                    None,
-                    Vec::new(),
-                )
+            .map_err(|e| ShellError::GenericError {
+                error: "Parquet reader error".into(),
+                msg: format!("{e:?}"),
+                span: Some(call.head),
+                help: None,
+                inner: vec![],
             })?
             .into();
 

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

@@ -28,8 +28,10 @@ impl Command for QueryDf {
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .required("sql", SyntaxShape::String, "sql query")
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -74,22 +76,19 @@ fn command(
 
     let mut ctx = SQLContext::new();
     ctx.register("df", &df.df);
-    let df_sql = ctx.execute(&sql_query).map_err(|e| {
-        ShellError::GenericError(
-            "Dataframe Error".into(),
-            e.to_string(),
-            Some(call.head),
-            None,
-            Vec::new(),
-        )
-    })?;
+    let df_sql = ctx
+        .execute(&sql_query)
+        .map_err(|e| ShellError::GenericError {
+            error: "Dataframe Error".into(),
+            msg: e.to_string(),
+            span: Some(call.head),
+            help: None,
+            inner: vec![],
+        })?;
     let lazy = NuLazyFrame::new(false, df_sql);
 
     let eager = lazy.collect(call.head)?;
-    let value = Value::CustomValue {
-        val: Box::new(eager),
-        span: call.head,
-    };
+    let value = Value::custom_value(Box::new(eager), call.head);
 
     Ok(PipelineData::Value(value, None))
 }

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

@@ -33,8 +33,10 @@ impl Command for RenameDF {
                 SyntaxShape::Any,
                 "New names for the selected column(s). A string or list of strings",
             )
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe or lazyframe".into()))
     }
 
@@ -128,15 +130,15 @@ fn command_eager(
     let new_names = extract_strings(new_names)?;
 
     for (from, to) in columns.iter().zip(new_names.iter()) {
-        df.as_mut().rename(from, to).map_err(|e| {
-            ShellError::GenericError(
-                "Error renaming".into(),
-                e.to_string(),
-                Some(call.head),
-                None,
-                Vec::new(),
-            )
-        })?;
+        df.as_mut()
+            .rename(from, to)
+            .map_err(|e| ShellError::GenericError {
+                error: "Error renaming".into(),
+                msg: e.to_string(),
+                span: Some(call.head),
+                help: None,
+                inner: vec![],
+            })?;
     }
 
     Ok(PipelineData::Value(df.into_value(call.head), None))
@@ -158,7 +160,7 @@ fn command_lazy(
         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()?,
+            span: value.span(),
         });
     }
 

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

@@ -4,6 +4,8 @@ use nu_protocol::{
     engine::{Command, EngineState, Stack},
     Category, Example, PipelineData, ShellError, Signature, Spanned, SyntaxShape, Type,
 };
+use polars::prelude::NamedFrom;
+use polars::series::Series;
 
 use super::super::values::NuDataFrame;
 
@@ -41,8 +43,10 @@ impl Command for SampleDF {
             )
             .switch("replace", "sample with replace", Some('e'))
             .switch("shuffle", "shuffle sample", Some('u'))
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -50,12 +54,13 @@ impl Command for SampleDF {
         vec![
             Example {
                 description: "Sample rows from dataframe",
-                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr sample -n 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]] | dfr into-df | dfr sample -f 0.5 -e",
+                example:
+                    "[[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
             },
         ]
@@ -78,7 +83,7 @@ fn command(
     call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let rows: Option<Spanned<usize>> = call.get_flag(engine_state, stack, "n-rows")?;
+    let rows: Option<Spanned<i64>> = call.get_flag(engine_state, stack, "n-rows")?;
     let fraction: Option<Spanned<f64>> = call.get_flag(engine_state, stack, "fraction")?;
     let seed: Option<u64> = call
         .get_flag::<i64>(engine_state, stack, "seed")?
@@ -91,42 +96,38 @@ fn command(
     match (rows, fraction) {
         (Some(rows), None) => df
             .as_ref()
-            .sample_n(rows.item, replace, shuffle, seed)
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "Error creating sample".into(),
-                    e.to_string(),
-                    Some(rows.span),
-                    None,
-                    Vec::new(),
-                )
+            .sample_n(&Series::new("s", &[rows.item]), replace, shuffle, seed)
+            .map_err(|e| ShellError::GenericError {
+                error: "Error creating sample".into(),
+                msg: e.to_string(),
+                span: Some(rows.span),
+                help: None,
+                inner: vec![],
             }),
         (None, Some(frac)) => df
             .as_ref()
-            .sample_frac(frac.item, replace, shuffle, seed)
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "Error creating sample".into(),
-                    e.to_string(),
-                    Some(frac.span),
-                    None,
-                    Vec::new(),
-                )
+            .sample_frac(&Series::new("frac", &[frac.item]), replace, shuffle, seed)
+            .map_err(|e| ShellError::GenericError {
+                error: "Error creating sample".into(),
+                msg: e.to_string(),
+                span: Some(frac.span),
+                help: None,
+                inner: vec![],
             }),
-        (Some(_), Some(_)) => Err(ShellError::GenericError(
-            "Incompatible flags".into(),
-            "Only one selection criterion allowed".into(),
-            Some(call.head),
-            None,
-            Vec::new(),
-        )),
-        (None, None) => Err(ShellError::GenericError(
-            "No selection".into(),
-            "No selection criterion was found".into(),
-            Some(call.head),
-            Some("Perhaps you want to use the flag -n or -f".into()),
-            Vec::new(),
-        )),
+        (Some(_), Some(_)) => Err(ShellError::GenericError {
+            error: "Incompatible flags".into(),
+            msg: "Only one selection criterion allowed".into(),
+            span: Some(call.head),
+            help: None,
+            inner: vec![],
+        }),
+        (None, None) => Err(ShellError::GenericError {
+            error: "No selection".into(),
+            msg: "No selection criterion was found".into(),
+            span: Some(call.head),
+            help: Some("Perhaps you want to use the flag -n or -f".into()),
+            inner: vec![],
+        }),
     }
     .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
 }

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

@@ -22,8 +22,10 @@ impl Command for ShapeDF {
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 

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

@@ -25,8 +25,10 @@ impl Command for SliceDF {
         Signature::build(self.name())
             .required("offset", SyntaxShape::Int, "start of slice")
             .required("size", SyntaxShape::Int, "size of slice")
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 

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

@@ -2,7 +2,8 @@ use crate::dataframe::eager::sql_expr::parse_sql_expr;
 use polars::error::{ErrString, PolarsError};
 use polars::prelude::{col, DataFrame, DataType, IntoLazy, LazyFrame};
 use sqlparser::ast::{
-    Expr as SqlExpr, Select, SelectItem, SetExpr, Statement, TableFactor, Value as SQLValue,
+    Expr as SqlExpr, GroupByExpr, Select, SelectItem, SetExpr, Statement, TableFactor,
+    Value as SQLValue,
 };
 use sqlparser::dialect::GenericDialect;
 use sqlparser::parser::Parser;
@@ -18,7 +19,7 @@ impl SQLContext {
     pub fn new() -> Self {
         Self {
             table_map: HashMap::new(),
-            dialect: GenericDialect::default(),
+            dialect: GenericDialect,
         }
     }
 
@@ -29,7 +30,7 @@ impl SQLContext {
     fn execute_select(&self, select_stmt: &Select) -> Result<LazyFrame, PolarsError> {
         // Determine involved dataframe
         // Implicit join require some more work in query parsers, Explicit join are preferred for now.
-        let tbl = select_stmt.from.get(0).ok_or_else(|| {
+        let tbl = select_stmt.from.first().ok_or_else(|| {
             PolarsError::ComputeError(ErrString::from("No table found in select statement"))
         })?;
         let mut alias_map = HashMap::new();
@@ -37,7 +38,7 @@ impl SQLContext {
             TableFactor::Table { name, alias, .. } => {
                 let tbl_name = name
                     .0
-                    .get(0)
+                    .first()
                     .ok_or_else(|| {
                         PolarsError::ComputeError(ErrString::from(
                             "No table found in select statement",
@@ -96,8 +97,13 @@ impl SQLContext {
             .collect::<Result<Vec<_>, PolarsError>>()?;
         // Check for group by
         // After projection since there might be number.
-        let group_by = select_stmt
-            .group_by
+        let group_by = match &select_stmt.group_by {
+                GroupByExpr::All =>
+                  Err(
+                      PolarsError::ComputeError("Group-By Error: Only positive number or expression are supported, not all".into())
+                  )?,
+                GroupByExpr::Expressions(expressions) => expressions
+            }
             .iter()
             .map(
                 |e|match e {
@@ -147,10 +153,10 @@ impl SQLContext {
                 .enumerate()
                 .map(|(agg_pj, (proj_p, expr))| (expr.clone(), (proj_p, agg_pj + group_by.len())))
                 .unzip();
-            let agg_df = df.groupby(group_by).agg(agg_projection);
+            let agg_df = df.group_by(group_by).agg(agg_projection);
             let mut final_proj_pos = groupby_pos
                 .into_iter()
-                .chain(agg_proj_pos.into_iter())
+                .chain(agg_proj_pos)
                 .collect::<Vec<_>>();
 
             final_proj_pos.sort_by(|(proj_pa, _), (proj_pb, _)| proj_pa.cmp(proj_pb));
@@ -182,7 +188,7 @@ impl SQLContext {
             ))
         } else {
             let ast = ast
-                .get(0)
+                .first()
                 .ok_or_else(|| PolarsError::ComputeError(ErrString::from("No statement found")))?;
             Ok(match ast {
                 Statement::Query(query) => {

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

@@ -2,8 +2,8 @@ use polars::error::PolarsError;
 use polars::prelude::{col, lit, DataType, Expr, LiteralValue, PolarsResult as Result, TimeUnit};
 
 use sqlparser::ast::{
-    BinaryOperator as SQLBinaryOperator, DataType as SQLDataType, Expr as SqlExpr,
-    Function as SQLFunction, Value as SqlValue, WindowSpec,
+    ArrayElemTypeDef, BinaryOperator as SQLBinaryOperator, DataType as SQLDataType,
+    Expr as SqlExpr, Function as SQLFunction, Value as SqlValue, WindowType,
 };
 
 fn map_sql_polars_datatype(data_type: &SQLDataType) -> Result<DataType> {
@@ -13,7 +13,7 @@ fn map_sql_polars_datatype(data_type: &SQLDataType) -> Result<DataType> {
         | SQLDataType::Uuid
         | SQLDataType::Clob(_)
         | SQLDataType::Text
-        | SQLDataType::String => DataType::Utf8,
+        | SQLDataType::String(_) => DataType::Utf8,
         SQLDataType::Float(_) => DataType::Float32,
         SQLDataType::Real => DataType::Float32,
         SQLDataType::Double => DataType::Float64,
@@ -31,9 +31,12 @@ fn map_sql_polars_datatype(data_type: &SQLDataType) -> Result<DataType> {
         SQLDataType::Time(_, _) => DataType::Time,
         SQLDataType::Timestamp(_, _) => DataType::Datetime(TimeUnit::Microseconds, None),
         SQLDataType::Interval => DataType::Duration(TimeUnit::Microseconds),
-        SQLDataType::Array(inner_type) => match inner_type {
-            Some(inner_type) => DataType::List(Box::new(map_sql_polars_datatype(inner_type)?)),
-            None => {
+        SQLDataType::Array(array_type_def) => match array_type_def {
+            ArrayElemTypeDef::AngleBracket(inner_type)
+            | ArrayElemTypeDef::SquareBracket(inner_type) => {
+                DataType::List(Box::new(map_sql_polars_datatype(inner_type)?))
+            }
+            _ => {
                 return Err(PolarsError::ComputeError(
                     "SQL Datatype Array(None) was not supported in polars-sql yet!".into(),
                 ))
@@ -114,7 +117,11 @@ pub fn parse_sql_expr(expr: &SqlExpr) -> Result<Expr> {
             binary_op_(left, right, op)?
         }
         SqlExpr::Function(sql_function) => parse_sql_function(sql_function)?,
-        SqlExpr::Cast { expr, data_type } => cast_(parse_sql_expr(expr)?, data_type)?,
+        SqlExpr::Cast {
+            expr,
+            data_type,
+            format: _,
+        } => cast_(parse_sql_expr(expr)?, data_type)?,
         SqlExpr::Nested(expr) => parse_sql_expr(expr)?,
         SqlExpr::Value(value) => literal_expr(value)?,
         _ => {
@@ -125,18 +132,26 @@ pub fn parse_sql_expr(expr: &SqlExpr) -> Result<Expr> {
     })
 }
 
-fn apply_window_spec(expr: Expr, window_spec: &Option<WindowSpec>) -> Result<Expr> {
-    Ok(match &window_spec {
-        Some(window_spec) => {
-            // Process for simple window specification, partition by first
-            let partition_by = window_spec
-                .partition_by
-                .iter()
-                .map(parse_sql_expr)
-                .collect::<Result<Vec<_>>>()?;
-            expr.over(partition_by)
-            // Order by and Row range may not be supported at the moment
-        }
+fn apply_window_spec(expr: Expr, window_type: Option<&WindowType>) -> Result<Expr> {
+    Ok(match &window_type {
+        Some(wtype) => match wtype {
+            WindowType::WindowSpec(window_spec) => {
+                // Process for simple window specification, partition by first
+                let partition_by = window_spec
+                    .partition_by
+                    .iter()
+                    .map(parse_sql_expr)
+                    .collect::<Result<Vec<_>>>()?;
+                expr.over(partition_by)
+                // Order by and Row range may not be supported at the moment
+            }
+            // TODO: make NamedWindow work
+            WindowType::NamedWindow(_named) => {
+                return Err(PolarsError::ComputeError(
+                    format!("Expression: {expr:?} was not supported in polars-sql yet!").into(),
+                ))
+            }
+        },
         None => expr,
     })
 }
@@ -144,7 +159,7 @@ fn apply_window_spec(expr: Expr, window_spec: &Option<WindowSpec>) -> Result<Exp
 fn parse_sql_function(sql_function: &SQLFunction) -> Result<Expr> {
     use sqlparser::ast::{FunctionArg, FunctionArgExpr};
     // Function name mostly do not have name space, so it mostly take the first args
-    let function_name = sql_function.name.0[0].value.to_lowercase();
+    let function_name = sql_function.name.0[0].value.to_ascii_lowercase();
     let args = sql_function
         .args
         .iter()
@@ -160,13 +175,13 @@ fn parse_sql_function(sql_function: &SQLFunction) -> Result<Expr> {
             sql_function.distinct,
         ) {
             ("sum", [FunctionArgExpr::Expr(expr)], false) => {
-                apply_window_spec(parse_sql_expr(expr)?, &sql_function.over)?.sum()
+                apply_window_spec(parse_sql_expr(expr)?, sql_function.over.as_ref())?.sum()
             }
             ("count", [FunctionArgExpr::Expr(expr)], false) => {
-                apply_window_spec(parse_sql_expr(expr)?, &sql_function.over)?.count()
+                apply_window_spec(parse_sql_expr(expr)?, sql_function.over.as_ref())?.count()
             }
             ("count", [FunctionArgExpr::Expr(expr)], true) => {
-                apply_window_spec(parse_sql_expr(expr)?, &sql_function.over)?.n_unique()
+                apply_window_spec(parse_sql_expr(expr)?, sql_function.over.as_ref())?.n_unique()
             }
             // Special case for wildcard args to count function.
             ("count", [FunctionArgExpr::Wildcard], false) => lit(1i32).count(),

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

@@ -29,11 +29,13 @@ impl Command for Summary {
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .category(Category::Custom("dataframe".into()))
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .named(
                 "quantiles",
-                SyntaxShape::Table,
+                SyntaxShape::Table(vec![]),
                 "provide optional quantiles",
                 Some('q'),
             )
@@ -118,30 +120,31 @@ fn command(
     let quantiles = quantiles.map(|values| {
         values
             .iter()
-            .map(|value| match value {
-                Value::Float { val, span } => {
-                    if (&0.0..=&1.0).contains(&val) {
-                        Ok(*val)
-                    } else {
-                        Err(ShellError::GenericError(
-                            "Incorrect value for quantile".to_string(),
-                            "value should be between 0 and 1".to_string(),
-                            Some(*span),
-                            None,
-                            Vec::new(),
-                        ))
+            .map(|value| {
+                let span = value.span();
+                match value {
+                    Value::Float { val, .. } => {
+                        if (&0.0..=&1.0).contains(&val) {
+                            Ok(*val)
+                        } else {
+                            Err(ShellError::GenericError {
+                                error: "Incorrect value for quantile".into(),
+                                msg: "value should be between 0 and 1".into(),
+                                span: Some(span),
+                                help: None,
+                                inner: vec![],
+                            })
+                        }
                     }
+                    Value::Error { error, .. } => Err(*error.clone()),
+                    _ => Err(ShellError::GenericError {
+                        error: "Incorrect value for quantile".into(),
+                        msg: "value should be a float".into(),
+                        span: Some(span),
+                        help: None,
+                        inner: vec![],
+                    }),
                 }
-                _ => match value.span() {
-                    Ok(span) => Err(ShellError::GenericError(
-                        "Incorrect value for quantile".to_string(),
-                        "value should be a float".to_string(),
-                        Some(span),
-                        None,
-                        Vec::new(),
-                    )),
-                    Err(e) => Err(e),
-                },
             })
             .collect::<Result<Vec<f64>, ShellError>>()
     });
@@ -247,14 +250,12 @@ fn command(
     let res = head.chain(tail).collect::<Vec<Series>>();
 
     DataFrame::new(res)
-        .map_err(|e| {
-            ShellError::GenericError(
-                "Dataframe Error".into(),
-                e.to_string(),
-                Some(call.head),
-                None,
-                Vec::new(),
-            )
+        .map_err(|e| ShellError::GenericError {
+            error: "Dataframe Error".into(),
+            msg: e.to_string(),
+            span: Some(call.head),
+            help: None,
+            inner: vec![],
         })
         .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
 }

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

@@ -29,8 +29,10 @@ impl Command for TakeDF {
                 SyntaxShape::Any,
                 "list of indices used to take data",
             )
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(
+                Type::Custom("dataframe".into()),
+                Type::Custom("dataframe".into()),
+            )
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -91,51 +93,45 @@ fn command(
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
     let index_value: Value = call.req(engine_state, stack, 0)?;
-    let index_span = index_value.span()?;
+    let index_span = index_value.span();
     let index = NuDataFrame::try_from_value(index_value)?.as_series(index_span)?;
 
     let casted = match index.dtype() {
-        DataType::UInt32 | DataType::UInt64 | DataType::Int32 | DataType::Int64 => {
-            index.cast(&DataType::UInt32).map_err(|e| {
-                ShellError::GenericError(
-                    "Error casting index list".into(),
-                    e.to_string(),
-                    Some(index_span),
-                    None,
-                    Vec::new(),
-                )
-            })
-        }
-        _ => Err(ShellError::GenericError(
-            "Incorrect type".into(),
-            "Series with incorrect type".into(),
-            Some(call.head),
-            Some("Consider using a Series with type int type".into()),
-            Vec::new(),
-        )),
+        DataType::UInt32 | DataType::UInt64 | DataType::Int32 | DataType::Int64 => index
+            .cast(&DataType::UInt32)
+            .map_err(|e| ShellError::GenericError {
+                error: "Error casting index list".into(),
+                msg: e.to_string(),
+                span: Some(index_span),
+                help: None,
+                inner: vec![],
+            }),
+        _ => Err(ShellError::GenericError {
+            error: "Incorrect type".into(),
+            msg: "Series with incorrect type".into(),
+            span: Some(call.head),
+            help: Some("Consider using a Series with type int type".into()),
+            inner: vec![],
+        }),
     }?;
 
-    let indices = casted.u32().map_err(|e| {
-        ShellError::GenericError(
-            "Error casting index list".into(),
-            e.to_string(),
-            Some(index_span),
-            None,
-            Vec::new(),
-        )
+    let indices = casted.u32().map_err(|e| ShellError::GenericError {
+        error: "Error casting index list".into(),
+        msg: e.to_string(),
+        span: Some(index_span),
+        help: None,
+        inner: vec![],
     })?;
 
     NuDataFrame::try_from_pipeline(input, call.head).and_then(|df| {
         df.as_ref()
             .take(indices)
-            .map_err(|e| {
-                ShellError::GenericError(
-                    "Error taking values".into(),
-                    e.to_string(),
-                    Some(call.head),
-                    None,
-                    Vec::new(),
-                )
+            .map_err(|e| ShellError::GenericError {
+                error: "Error taking values".into(),
+                msg: e.to_string(),
+                span: Some(call.head),
+                help: None,
+                inner: vec![],
             })
             .map(|df| PipelineData::Value(NuDataFrame::dataframe_into_value(df, call.head), None))
     })

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

@@ -25,8 +25,7 @@ impl Command for ToArrow {
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .required("file", SyntaxShape::Filepath, "file path to save dataframe")
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Any)
+            .input_output_type(Type::Custom("dataframe".into()), Type::Any)
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -59,36 +58,28 @@ fn command(
 
     let mut df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
-    let mut file = File::create(&file_name.item).map_err(|e| {
-        ShellError::GenericError(
-            "Error with file name".into(),
-            e.to_string(),
-            Some(file_name.span),
-            None,
-            Vec::new(),
-        )
+    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 saving file".into(),
-            e.to_string(),
-            Some(file_name.span),
-            None,
-            Vec::new(),
-        )
-    })?;
+    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 {
-        val: format!("saved {:?}", &file_name.item),
-        span: file_name.span,
-    };
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
 
     Ok(PipelineData::Value(
-        Value::List {
-            vals: vec![file_value],
-            span: call.head,
-        },
+        Value::list(vec![file_value], call.head),
         None,
     ))
 }

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

@@ -0,0 +1,113 @@
+use std::{fs::File, path::PathBuf};
+
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Spanned, SyntaxShape, Type, Value,
+};
+use polars_io::avro::{AvroCompression, AvroWriter};
+use polars_io::SerWriter;
+
+use super::super::values::NuDataFrame;
+
+#[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

@@ -32,8 +32,7 @@ impl Command for ToCSV {
                 Some('d'),
             )
             .switch("no-header", "Indicates if file doesn't have header", None)
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Any)
+            .input_output_type(Type::Custom("dataframe".into()), Type::Any)
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -46,7 +45,7 @@ impl Command for ToCSV {
             },
             Example {
                 description: "Saves dataframe to CSV file using other delimiter",
-                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr to-csv test.csv -d '|'",
+                example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr to-csv test.csv --delimiter '|'",
                 result: None,
             },
         ]
@@ -75,66 +74,58 @@ fn command(
 
     let mut df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
-    let mut file = File::create(&file_name.item).map_err(|e| {
-        ShellError::GenericError(
-            "Error with file name".into(),
-            e.to_string(),
-            Some(file_name.span),
-            None,
-            Vec::new(),
-        )
+    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![],
     })?;
 
     let writer = CsvWriter::new(&mut file);
 
     let writer = if no_header {
-        writer.has_header(false)
+        writer.include_header(false)
     } else {
-        writer.has_header(true)
+        writer.include_header(true)
     };
 
     let mut writer = match delimiter {
         None => writer,
         Some(d) => {
             if d.item.len() != 1 {
-                return Err(ShellError::GenericError(
-                    "Incorrect delimiter".into(),
-                    "Delimiter has to be one char".into(),
-                    Some(d.span),
-                    None,
-                    Vec::new(),
-                ));
+                return Err(ShellError::GenericError {
+                    error: "Incorrect delimiter".into(),
+                    msg: "Delimiter has to be one char".into(),
+                    span: Some(d.span),
+                    help: None,
+                    inner: vec![],
+                });
             } else {
                 let delimiter = match d.item.chars().next() {
                     Some(d) => d as u8,
                     None => unreachable!(),
                 };
 
-                writer.with_delimiter(delimiter)
+                writer.with_separator(delimiter)
             }
         }
     };
 
-    writer.finish(df.as_mut()).map_err(|e| {
-        ShellError::GenericError(
-            "Error writing to file".into(),
-            e.to_string(),
-            Some(file_name.span),
-            None,
-            Vec::new(),
-        )
-    })?;
+    writer
+        .finish(df.as_mut())
+        .map_err(|e| ShellError::GenericError {
+            error: "Error writing to file".into(),
+            msg: e.to_string(),
+            span: Some(file_name.span),
+            help: None,
+            inner: vec![],
+        })?;
 
-    let file_value = Value::String {
-        val: format!("saved {:?}", &file_name.item),
-        span: file_name.span,
-    };
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
 
     Ok(PipelineData::Value(
-        Value::List {
-            vals: vec![file_value],
-            span: call.head,
-        },
+        Value::list(vec![file_value], call.head),
         None,
     ))
 }

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

@@ -20,8 +20,7 @@ impl Command for ToDataFrame {
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
-            .input_type(Type::Any)
-            .output_type(Type::Custom("dataframe".into()))
+            .input_output_type(Type::Any, Type::Custom("dataframe".into()))
             .category(Category::Custom("dataframe".into()))
     }
 

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

@@ -25,8 +25,7 @@ impl Command for ToJsonLines {
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .required("file", SyntaxShape::Filepath, "file path to save dataframe")
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Any)
+            .input_output_type(Type::Custom("dataframe".into()), Type::Any)
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -59,39 +58,29 @@ fn command(
 
     let mut df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
-    let file = File::create(&file_name.item).map_err(|e| {
-        ShellError::GenericError(
-            "Error with file name".into(),
-            e.to_string(),
-            Some(file_name.span),
-            None,
-            Vec::new(),
-        )
+    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 saving file".into(),
-                e.to_string(),
-                Some(file_name.span),
-                None,
-                Vec::new(),
-            )
+        .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 {
-        val: format!("saved {:?}", &file_name.item),
-        span: file_name.span,
-    };
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
 
     Ok(PipelineData::Value(
-        Value::List {
-            vals: vec![file_value],
-            span: call.head,
-        },
+        Value::list(vec![file_value], call.head),
         None,
     ))
 }

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

@@ -2,9 +2,11 @@ use nu_engine::CallExt;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+    record, Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
 };
 
+use crate::dataframe::values::NuExpression;
+
 use super::super::values::NuDataFrame;
 
 #[derive(Clone)]
@@ -16,7 +18,7 @@ impl Command for ToNu {
     }
 
     fn usage(&self) -> &str {
-        "Converts a section of the dataframe into nushell Table."
+        "Converts a dataframe or an expression into into nushell value for access and exploration."
     }
 
     fn signature(&self) -> Signature {
@@ -28,45 +30,49 @@ impl Command for ToNu {
                 Some('n'),
             )
             .switch("tail", "shows tail rows", Some('t'))
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Any)
+            .input_output_types(vec![
+                (Type::Custom("expression".into()), Type::Any),
+                (Type::Custom("dataframe".into()), Type::Table(vec![])),
+            ])
+            //.input_output_type(Type::Any, Type::Any)
             .category(Category::Custom("dataframe".into()))
     }
 
     fn examples(&self) -> Vec<Example> {
-        let cols = vec!["index".into(), "a".into(), "b".into()];
-        let rec_1 = Value::Record {
-            cols: cols.clone(),
-            vals: vec![Value::test_int(0), Value::test_int(1), Value::test_int(2)],
-            span: Span::test_data(),
-        };
-        let rec_2 = Value::Record {
-            cols: cols.clone(),
-            vals: vec![Value::test_int(1), Value::test_int(3), Value::test_int(4)],
-            span: Span::test_data(),
-        };
-        let rec_3 = Value::Record {
-            cols,
-            vals: vec![Value::test_int(2), Value::test_int(3), Value::test_int(4)],
-            span: Span::test_data(),
-        };
+        let rec_1 = Value::test_record(record! {
+            "index" => Value::test_int(0),
+            "a" =>     Value::test_int(1),
+            "b" =>     Value::test_int(2),
+        });
+        let rec_2 = Value::test_record(record! {
+            "index" => Value::test_int(1),
+            "a" =>     Value::test_int(3),
+            "b" =>     Value::test_int(4),
+        });
+        let rec_3 = Value::test_record(record! {
+            "index" => Value::test_int(2),
+            "a" =>     Value::test_int(3),
+            "b" =>     Value::test_int(4),
+        });
 
         vec![
             Example {
                 description: "Shows head rows from dataframe",
                 example: "[[a b]; [1 2] [3 4]] | dfr into-df | dfr into-nu",
-                result: Some(Value::List {
-                    vals: vec![rec_1, rec_2],
-                    span: Span::test_data(),
-                }),
+                result: Some(Value::list(vec![rec_1, rec_2], Span::test_data())),
             },
             Example {
                 description: "Shows tail rows from dataframe",
-                example: "[[a b]; [1 2] [5 6] [3 4]] | dfr into-df | dfr into-nu -t -n 1",
-                result: Some(Value::List {
-                    vals: vec![rec_3],
-                    span: Span::test_data(),
-                }),
+                example: "[[a b]; [1 2] [5 6] [3 4]] | dfr into-df | dfr 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: "dfr col a | dfr into-nu",
+                result: Some(Value::test_record(record! {
+                    "expr" =>  Value::test_string("column"),
+                    "value" => Value::test_string("a"),
+                })),
             },
         ]
     }
@@ -78,20 +84,25 @@ impl Command for ToNu {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        command(engine_state, stack, call, input)
+        let value = input.into_value(call.head);
+        if NuDataFrame::can_downcast(&value) {
+            dataframe_command(engine_state, stack, call, value)
+        } else {
+            expression_command(call, value)
+        }
     }
 }
 
-fn command(
+fn dataframe_command(
     engine_state: &EngineState,
     stack: &mut Stack,
     call: &Call,
-    input: PipelineData,
+    input: Value,
 ) -> Result<PipelineData, ShellError> {
     let rows: Option<usize> = call.get_flag(engine_state, stack, "rows")?;
     let tail: bool = call.has_flag("tail");
 
-    let df = NuDataFrame::try_from_pipeline(input, call.head)?;
+    let df = NuDataFrame::try_from_value(input)?;
 
     let values = if tail {
         df.tail(rows, call.head)?
@@ -104,21 +115,30 @@ fn command(
         }
     };
 
-    let value = Value::List {
-        vals: values,
-        span: call.head,
-    };
+    let value = Value::list(values, call.head);
+
+    Ok(PipelineData::Value(value, None))
+}
+fn expression_command(call: &Call, input: Value) -> Result<PipelineData, ShellError> {
+    let expr = NuExpression::try_from_value(input)?;
+    let value = expr.to_value(call.head)?;
 
     Ok(PipelineData::Value(value, None))
 }
 
 #[cfg(test)]
 mod test {
+    use super::super::super::expressions::ExprCol;
     use super::super::super::test_dataframe::test_dataframe;
     use super::*;
 
     #[test]
-    fn test_examples() {
+    fn test_examples_dataframe_input() {
         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

@@ -25,8 +25,7 @@ impl Command for ToParquet {
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .required("file", SyntaxShape::Filepath, "file path to save dataframe")
-            .input_type(Type::Custom("dataframe".into()))
-            .output_type(Type::Any)
+            .input_output_type(Type::Custom("dataframe".into()), Type::Any)
             .category(Category::Custom("dataframe".into()))
     }
 
@@ -59,36 +58,28 @@ fn command(
 
     let mut df = NuDataFrame::try_from_pipeline(input, call.head)?;
 
-    let file = File::create(&file_name.item).map_err(|e| {
-        ShellError::GenericError(
-            "Error with file name".into(),
-            e.to_string(),
-            Some(file_name.span),
-            None,
-            Vec::new(),
-        )
+    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 saving file".into(),
-            e.to_string(),
-            Some(file_name.span),
-            None,
-            Vec::new(),
-        )
-    })?;
+    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 {
-        val: format!("saved {:?}", &file_name.item),
-        span: file_name.span,
-    };
+    let file_value = Value::string(format!("saved {:?}", &file_name.item), file_name.span);
 
     Ok(PipelineData::Value(
-        Value::List {
-            vals: vec![file_value],
-            span: call.head,
-        },
+        Value::list(vec![file_value], call.head),
         None,
     ))
 }