nu-cli refactor moving commands into their own crate nu-command (#2910)

* move commands, futures.rs, script.rs, utils

* move over maybe_print_errors

* add nu_command crate references to nu_cli

* in commands.rs open up to pub mod from pub(crate)

* nu-cli, nu-command, and nu tests are now passing

* cargo fmt

* clean up nu-cli/src/prelude.rs

* code cleanup

* for some reason lex.rs was not formatted, may be causing my error

* remove mod completion from lib.rs which was not being used along with quickcheck macros

* add in allow unused imports

* comment out one failing external test; comment out one failing internal test

* revert commenting out failing tests; something else might be going on; someone with a windows machine should check and see what is going on with these failing windows tests

* Update Cargo.toml

Extend the optional features to nu-command

Co-authored-by: Jonathan Turner <jonathandturner@users.noreply.github.com>

crates/nu-command/Cargo.toml

@@ -0,0 +1,134 @@
+[package]
+authors = ["The Nu Project Contributors"]
+build = "build.rs"
+description = "CLI for nushell"
+edition = "2018"
+license = "MIT"
+name = "nu-command"
+version = "0.25.2"
+
+[lib]
+doctest = false
+
+[dependencies]
+nu-data = {version = "0.25.2", path = "../nu-data"}
+nu-engine = {version = "0.25.2", path = "../nu-engine"}
+nu-errors = {version = "0.25.2", path = "../nu-errors"}
+nu-json = {version = "0.25.2", path = "../nu-json"}
+nu-parser = {version = "0.25.2", path = "../nu-parser"}
+nu-plugin = {version = "0.25.2", path = "../nu-plugin"}
+nu-protocol = {version = "0.25.2", path = "../nu-protocol"}
+nu-source = {version = "0.25.2", path = "../nu-source"}
+nu-stream = {version = "0.25.2", path = "../nu-stream"}
+nu-table = {version = "0.25.2", path = "../nu-table"}
+nu-test-support = {version = "0.25.2", path = "../nu-test-support"}
+nu-value-ext = {version = "0.25.2", path = "../nu-value-ext"}
+
+Inflector = "0.11"
+ansi_term = "0.12.1"
+arboard = {version = "1.1.0", optional = true}
+async-recursion = "0.3.1"
+async-trait = "0.1.40"
+base64 = "0.13.0"
+bigdecimal = {version = "0.2.0", features = ["serde"]}
+byte-unit = "4.0.9"
+bytes = "0.5.6"
+calamine = "0.16.1"
+chrono = {version = "0.4.15", features = ["serde"]}
+chrono-tz = "0.5.3"
+clap = "2.33.3"
+codespan-reporting = "0.11.0"
+csv = "1.1.3"
+ctrlc = {version = "3.1.6", optional = true}
+derive-new = "0.5.8"
+directories = {version = "3.0.1", optional = true}
+dirs = {version = "3.0.1", optional = true}
+dtparse = "1.2.0"
+dunce = "1.0.1"
+eml-parser = "0.1.0"
+encoding_rs = "0.8.24"
+filesize = "0.2.0"
+fs_extra = "1.2.0"
+futures = {version = "0.3.5", features = ["compat", "io-compat"]}
+futures-util = "0.3.8"
+futures_codec = "0.4.1"
+getset = "0.1.1"
+git2 = {version = "0.13.11", default_features = false, optional = true}
+glob = "0.3.0"
+heim = {version = "0.1.0-rc.1", optional = true}
+htmlescape = "0.3.1"
+ical = "0.7.0"
+ichwh = {version = "0.3.4", optional = true}
+indexmap = {version = "1.6.0", features = ["serde-1"]}
+itertools = "0.10.0"
+lazy_static = "1.*"
+log = "0.4.11"
+meval = "0.2.0"
+num-bigint = {version = "0.3.0", features = ["serde"]}
+num-format = {version = "0.4.0", features = ["with-num-bigint"]}
+num-traits = "0.2.12"
+parking_lot = "0.11.0"
+pin-utils = "0.1.0"
+pretty-hex = "0.2.0"
+ptree = {version = "0.3.0", optional = true}
+query_interface = "0.3.5"
+quick-xml = "0.20.0"
+rand = "0.7.3"
+rayon = "1.4.0"
+regex = "1.3.9"
+roxmltree = "0.14.0"
+rust-embed = "5.8.0"
+rustyline = {version = "6.3.0", optional = true}
+serde = {version = "1.0.115", features = ["derive"]}
+serde_bytes = "0.11.5"
+serde_ini = "0.2.0"
+serde_json = "1.0.57"
+serde_urlencoded = "0.7.0"
+serde_yaml = "0.8.13"
+sha2 = "0.9.1"
+shellexpand = "2.0.0"
+strip-ansi-escapes = "0.1.0"
+sxd-document = "0.3.2"
+sxd-xpath = "0.4.2"
+tempfile = "3.1.0"
+term = {version = "0.6.1", optional = true}
+term_size = "0.3.2"
+termcolor = "1.1.0"
+titlecase = "1.0"
+toml = "0.5.6"
+trash = {version = "1.2.0", optional = true}
+unicode-segmentation = "1.6.0"
+uom = {version = "0.30.0", features = ["f64", "try-from"]}
+url = "2.1.1"
+uuid_crate = {package = "uuid", version = "0.8.1", features = ["v4"], optional = true}
+which = {version = "4.0.2", optional = true}
+zip = {version = "0.5.7", optional = true}
+
+[target.'cfg(unix)'.dependencies]
+umask = "1.0.0"
+users = "0.10.0"
+
+# TODO this will be possible with new dependency resolver
+#   (currently on nightly behind -Zfeatures=itarget):
+#   https://github.com/rust-lang/cargo/issues/7914
+#[target.'cfg(not(windows))'.dependencies]
+#num-format = {version = "0.4", features = ["with-system-locale"]}
+
+[dependencies.rusqlite]
+features = ["bundled", "blob"]
+optional = true
+version = "0.24.2"
+
+[build-dependencies]
+shadow-rs = "0.5"
+
+[dev-dependencies]
+quickcheck = "0.9.2"
+quickcheck_macros = "0.9.1"
+
+[features]
+clipboard-cli = ["arboard"]
+rich-benchmark = ["heim"]
+rustyline-support = ["rustyline"]
+stable = []
+trash-support = ["trash"]

crates/nu-command/build.rs

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

crates/nu-command/src/commands.rs

@@ -0,0 +1,328 @@
+#[macro_use]
+pub(crate) mod macros;
+
+mod from_delimited_data;
+mod to_delimited_data;
+
+pub(crate) mod ansi;
+pub(crate) mod append;
+pub(crate) mod args;
+pub mod autoenv;
+pub(crate) mod autoenv_trust;
+pub(crate) mod autoenv_untrust;
+pub(crate) mod autoview;
+pub(crate) mod benchmark;
+pub(crate) mod build_string;
+pub(crate) mod cal;
+pub(crate) mod cd;
+pub(crate) mod char_;
+pub(crate) mod chart;
+pub(crate) mod classified;
+#[cfg(feature = "clipboard-cli")]
+pub(crate) mod clip;
+pub mod command;
+pub(crate) mod compact;
+pub(crate) mod config;
+pub(crate) mod constants;
+pub(crate) mod count;
+pub(crate) mod cp;
+pub(crate) mod date;
+pub(crate) mod debug;
+pub(crate) mod def;
+pub(crate) mod default;
+pub mod default_context;
+pub(crate) mod describe;
+pub(crate) mod do_;
+pub(crate) mod drop;
+pub(crate) mod du;
+pub(crate) mod each;
+pub(crate) mod echo;
+pub(crate) mod empty;
+pub(crate) mod enter;
+pub(crate) mod every;
+pub(crate) mod exec;
+pub(crate) mod exit;
+pub(crate) mod first;
+pub(crate) mod flatten;
+pub(crate) mod format;
+pub(crate) mod from;
+pub(crate) mod from_csv;
+pub(crate) mod from_eml;
+pub(crate) mod from_ics;
+pub(crate) mod from_ini;
+pub(crate) mod from_json;
+pub(crate) mod from_ods;
+pub(crate) mod from_ssv;
+pub(crate) mod from_toml;
+pub(crate) mod from_tsv;
+pub(crate) mod from_url;
+pub(crate) mod from_vcf;
+pub(crate) mod from_xlsx;
+pub(crate) mod from_xml;
+pub(crate) mod from_yaml;
+pub(crate) mod get;
+pub(crate) mod group_by;
+pub(crate) mod group_by_date;
+pub(crate) mod hash_;
+pub(crate) mod headers;
+pub(crate) mod help;
+pub(crate) mod histogram;
+pub(crate) mod history;
+pub(crate) mod if_;
+pub(crate) mod insert;
+pub(crate) mod into_int;
+pub(crate) mod keep;
+pub(crate) mod last;
+pub(crate) mod let_;
+pub(crate) mod let_env;
+pub(crate) mod lines;
+pub(crate) mod ls;
+pub(crate) mod math;
+pub(crate) mod merge;
+pub(crate) mod mkdir;
+pub(crate) mod move_;
+pub(crate) mod next;
+pub(crate) mod nth;
+pub(crate) mod nu;
+pub(crate) mod open;
+pub(crate) mod parse;
+pub(crate) mod path;
+pub(crate) mod pivot;
+pub(crate) mod prepend;
+pub(crate) mod prev;
+pub(crate) mod pwd;
+pub(crate) mod random;
+pub(crate) mod range;
+pub(crate) mod reduce;
+pub(crate) mod reject;
+pub(crate) mod rename;
+pub(crate) mod reverse;
+pub(crate) mod rm;
+pub(crate) mod run_external;
+pub(crate) mod save;
+pub(crate) mod select;
+pub(crate) mod seq;
+pub(crate) mod seq_dates;
+pub(crate) mod shells;
+pub(crate) mod shuffle;
+pub(crate) mod size;
+pub(crate) mod skip;
+pub(crate) mod sleep;
+pub(crate) mod sort_by;
+pub(crate) mod source;
+pub(crate) mod split;
+pub(crate) mod split_by;
+pub(crate) mod str_;
+pub(crate) mod table;
+pub(crate) mod tags;
+pub(crate) mod to;
+pub(crate) mod to_csv;
+pub(crate) mod to_html;
+pub(crate) mod to_json;
+pub(crate) mod to_md;
+pub(crate) mod to_toml;
+pub(crate) mod to_tsv;
+pub(crate) mod to_url;
+pub(crate) mod to_xml;
+pub(crate) mod to_yaml;
+pub(crate) mod uniq;
+pub(crate) mod update;
+pub(crate) mod url_;
+pub(crate) mod version;
+pub(crate) mod where_;
+pub(crate) mod which_;
+pub(crate) mod with_env;
+pub(crate) mod wrap;
+
+pub(crate) use autoview::Autoview;
+pub(crate) use cd::Cd;
+
+pub(crate) use ansi::Ansi;
+pub(crate) use append::Command as Append;
+pub(crate) use autoenv::Autoenv;
+pub(crate) use autoenv_trust::AutoenvTrust;
+pub(crate) use autoenv_untrust::AutoenvUnTrust;
+pub(crate) use benchmark::Benchmark;
+pub(crate) use build_string::BuildString;
+pub(crate) use cal::Cal;
+pub(crate) use char_::Char;
+pub(crate) use chart::Chart;
+pub(crate) use compact::Compact;
+pub(crate) use config::{
+    Config, ConfigClear, ConfigGet, ConfigLoad, ConfigPath, ConfigRemove, ConfigSet, ConfigSetInto,
+};
+pub(crate) use count::Count;
+pub(crate) use cp::Cpy;
+pub(crate) use date::{Date, DateFormat, DateListTimeZone, DateNow, DateToTable, DateToTimeZone};
+pub(crate) use debug::Debug;
+pub(crate) use def::Def;
+pub(crate) use default::Default;
+pub(crate) use describe::Describe;
+pub(crate) use do_::Do;
+pub(crate) use drop::Drop;
+pub(crate) use du::Du;
+pub(crate) use each::Each;
+pub(crate) use each::EachGroup;
+pub(crate) use each::EachWindow;
+pub(crate) use echo::Echo;
+pub(crate) use empty::Command as Empty;
+pub(crate) use if_::If;
+pub(crate) use nu::NuPlugin;
+pub(crate) use update::Command as Update;
+pub(crate) mod kill;
+pub(crate) use kill::Kill;
+pub(crate) mod clear;
+pub(crate) use clear::Clear;
+pub(crate) mod touch;
+pub(crate) use enter::Enter;
+pub(crate) use every::Every;
+pub(crate) use exec::Exec;
+pub(crate) use exit::Exit;
+pub(crate) use first::First;
+pub(crate) use flatten::Command as Flatten;
+pub(crate) use format::{FileSize, Format};
+pub(crate) use from::From;
+pub(crate) use from_csv::FromCSV;
+pub(crate) use from_eml::FromEML;
+pub(crate) use from_ics::FromIcs;
+pub(crate) use from_ini::FromINI;
+pub(crate) use from_json::FromJSON;
+pub(crate) use from_ods::FromODS;
+pub(crate) use from_ssv::FromSSV;
+pub(crate) use from_toml::FromTOML;
+pub(crate) use from_tsv::FromTSV;
+pub(crate) use from_url::FromURL;
+pub(crate) use from_vcf::FromVcf;
+pub(crate) use from_xlsx::FromXLSX;
+pub(crate) use from_xml::FromXML;
+pub(crate) use from_yaml::FromYAML;
+pub(crate) use from_yaml::FromYML;
+pub(crate) use get::Get;
+pub(crate) use group_by::Command as GroupBy;
+pub(crate) use group_by_date::GroupByDate;
+pub(crate) use hash_::{Hash, HashBase64};
+pub(crate) use headers::Headers;
+pub(crate) use help::Help;
+pub(crate) use histogram::Histogram;
+pub(crate) use history::History;
+pub(crate) use insert::Command as Insert;
+pub(crate) use into_int::IntoInt;
+pub(crate) use keep::{Keep, KeepUntil, KeepWhile};
+pub(crate) use last::Last;
+pub(crate) use let_::Let;
+pub(crate) use let_env::LetEnv;
+pub(crate) use lines::Lines;
+pub(crate) use ls::Ls;
+pub(crate) use math::{
+    Math, MathAbs, MathAverage, MathCeil, MathEval, MathFloor, MathMaximum, MathMedian,
+    MathMinimum, MathMode, MathProduct, MathRound, MathStddev, MathSummation, MathVariance,
+};
+pub(crate) use merge::Merge;
+pub(crate) use mkdir::Mkdir;
+pub(crate) use move_::{Move, Mv};
+pub(crate) use next::Next;
+pub(crate) use nth::Nth;
+pub(crate) use open::Open;
+pub(crate) use parse::Parse;
+pub(crate) use path::{
+    PathBasename, PathCommand, PathDirname, PathExists, PathExpand, PathExtension, PathFilestem,
+    PathType,
+};
+pub(crate) use pivot::Pivot;
+pub(crate) use prepend::Prepend;
+pub(crate) use prev::Previous;
+pub(crate) use pwd::Pwd;
+#[cfg(feature = "uuid_crate")]
+pub(crate) use random::RandomUUID;
+pub(crate) use random::{
+    Random, RandomBool, RandomChars, RandomDecimal, RandomDice, RandomInteger,
+};
+pub(crate) use range::Range;
+pub(crate) use reduce::Reduce;
+pub(crate) use reject::Reject;
+pub(crate) use rename::Rename;
+pub(crate) use reverse::Reverse;
+pub(crate) use rm::Remove;
+pub(crate) use run_external::RunExternalCommand;
+pub(crate) use save::Save;
+pub(crate) use select::Select;
+pub(crate) use seq::Seq;
+pub(crate) use seq_dates::SeqDates;
+pub(crate) use shells::Shells;
+pub(crate) use shuffle::Shuffle;
+pub(crate) use size::Size;
+pub(crate) use skip::{Skip, SkipUntil, SkipWhile};
+pub(crate) use sleep::Sleep;
+pub(crate) use sort_by::SortBy;
+pub(crate) use source::Source;
+pub(crate) use split::{Split, SplitChars, SplitColumn, SplitRow};
+pub(crate) use split_by::SplitBy;
+pub(crate) use str_::{
+    Str, StrCamelCase, StrCapitalize, StrCollect, StrContains, StrDowncase, StrEndsWith,
+    StrFindReplace, StrFrom, StrIndexOf, StrKebabCase, StrLPad, StrLength, StrPascalCase, StrRPad,
+    StrReverse, StrScreamingSnakeCase, StrSet, StrSnakeCase, StrStartsWith, StrSubstring,
+    StrToDatetime, StrToDecimal, StrToInteger, StrTrim, StrTrimLeft, StrTrimRight, StrUpcase,
+};
+pub(crate) use table::Table;
+pub(crate) use tags::Tags;
+pub(crate) use to::To;
+pub(crate) use to_csv::ToCSV;
+pub(crate) use to_html::ToHTML;
+pub(crate) use to_json::ToJSON;
+pub(crate) use to_md::ToMarkdown;
+pub(crate) use to_toml::ToTOML;
+pub(crate) use to_tsv::ToTSV;
+pub(crate) use to_url::ToURL;
+pub(crate) use to_xml::ToXML;
+pub(crate) use to_yaml::ToYAML;
+pub(crate) use touch::Touch;
+pub(crate) use uniq::Uniq;
+pub(crate) use url_::{UrlCommand, UrlHost, UrlPath, UrlQuery, UrlScheme};
+pub(crate) use version::Version;
+pub(crate) use where_::Where;
+pub(crate) use which_::Which;
+pub(crate) use with_env::WithEnv;
+pub(crate) use wrap::Wrap;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::examples::{test_anchors, test_examples};
+    use nu_engine::{whole_stream_command, Command};
+    use nu_errors::ShellError;
+
+    fn full_tests() -> Vec<Command> {
+        vec![
+            whole_stream_command(Append),
+            whole_stream_command(GroupBy),
+            whole_stream_command(Insert),
+            whole_stream_command(Move),
+            whole_stream_command(Update),
+            whole_stream_command(Empty),
+        ]
+    }
+
+    fn only_examples() -> Vec<Command> {
+        let mut commands = full_tests();
+        commands.extend(vec![whole_stream_command(Flatten)]);
+        commands
+    }
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        for cmd in only_examples() {
+            test_examples(cmd)?;
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn tracks_metadata() -> Result<(), ShellError> {
+        for cmd in full_tests() {
+            test_anchors(cmd)?;
+        }
+
+        Ok(())
+    }
+}

crates/nu-command/src/commands/ansi.rs

@@ -0,0 +1,240 @@
+use crate::prelude::*;
+use ansi_term::Color;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct Ansi;
+
+#[derive(Deserialize)]
+struct AnsiArgs {
+    color: Value,
+    escape: Option<Tagged<String>>,
+    osc: Option<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Ansi {
+    fn name(&self) -> &str {
+        "ansi"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("ansi")
+            .optional(
+                "color",
+                SyntaxShape::Any,
+                "the name of the color to use or 'reset' to reset the color",
+            )
+            .named(
+                "escape", // \x1b
+                SyntaxShape::Any,
+                "escape sequence without the escape character(s)",
+                Some('e'),
+            )
+            .named(
+                "osc",
+                SyntaxShape::Any,
+                "operating system command (ocs) escape sequence without the escape character(s)",
+                Some('o'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        r#"Output ANSI codes to change color
+
+For escape sequences:
+Escape: '\x1b[' is not required for --escape parameter
+Format: #(;#)m
+Example: 1;31m for bold red or 2;37;41m for dimmed white fg with red bg
+There can be multiple text formatting sequence numbers
+separated by a ; and ending with an m where the # is of the
+following values:
+    attributes
+    0    reset / normal display
+    1    bold or increased intensity
+    2    faint or decreased intensity
+    3    italic on (non-mono font)
+    4    underline on
+    5    slow blink on
+    6    fast blink on
+    7    reverse video on
+    8    nondisplayed (invisible) on
+    9    strike-through on
+
+    foreground/bright colors    background/bright colors
+    30/90    black              40/100    black
+    31/91    red                41/101    red
+    32/92    green              42/102    green
+    33/93    yellow             43/103    yellow
+    34/94    blue               44/104    blue
+    35/95    magenta            45/105    magenta
+    36/96    cyan               46/106    cyan
+    37/97    white              47/107    white
+    https://en.wikipedia.org/wiki/ANSI_escape_code
+
+OSC: '\x1b]' is not required for --osc parameter
+Example: echo [$(ansi -o '0') 'some title' $(char bel)] | str collect
+Format: #
+    0 Set window title and icon name
+    1 Set icon name
+    2 Set window title
+    4 Set/read color palette
+    9 iTerm2 Grown notifications
+    10 Set foreground color (x11 color spec)
+    11 Set background color (x11 color spec)
+    ... others"#
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Change color to green",
+                example: r#"ansi green"#,
+                result: Some(vec![Value::from("\u{1b}[32m")]),
+            },
+            Example {
+                description: "Reset the color",
+                example: r#"ansi reset"#,
+                result: Some(vec![Value::from("\u{1b}[0m")]),
+            },
+            Example {
+                description:
+                    "Use ansi to color text (rb = red bold, gb = green bold, pb = purple bold)",
+                example: r#"echo [$(ansi rb) Hello " " $(ansi gb) Nu " " $(ansi pb) World] | str collect"#,
+                result: Some(vec![Value::from(
+                    "\u{1b}[1;31mHello \u{1b}[1;32mNu \u{1b}[1;35mWorld",
+                )]),
+            },
+            Example {
+                description:
+                    "Use ansi to color text (rb = red bold, gb = green bold, pb = purple bold)",
+                example: r#"echo [$(ansi -e '3;93;41m') Hello $(ansi reset) " " $(ansi gb) Nu " " $(ansi pb) World] | str collect"#,
+                result: Some(vec![Value::from(
+                    "\u{1b}[3;93;41mHello\u{1b}[0m \u{1b}[1;32mNu \u{1b}[1;35mWorld",
+                )]),
+            },
+        ]
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let (AnsiArgs { color, escape, osc }, _) = args.process().await?;
+
+        if let Some(e) = escape {
+            let esc_vec: Vec<char> = e.item.chars().collect();
+            if esc_vec[0] == '\\' {
+                return Err(ShellError::labeled_error(
+                    "no need for escape characters",
+                    "no need for escape characters",
+                    e.tag(),
+                ));
+            }
+            let output = format!("\x1b[{}", e.item);
+            return Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(e.tag()),
+            )));
+        }
+
+        if let Some(o) = osc {
+            let osc_vec: Vec<char> = o.item.chars().collect();
+            if osc_vec[0] == '\\' {
+                return Err(ShellError::labeled_error(
+                    "no need for escape characters",
+                    "no need for escape characters",
+                    o.tag(),
+                ));
+            }
+            //Operating system command aka osc  ESC ] <- note the right brace, not left brace for osc
+            // OCS's need to end with a bell '\x07' char
+            let output = format!("\x1b]{};", o.item);
+            return Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(o.tag()),
+            )));
+        }
+
+        let color_string = color.as_string()?;
+        let ansi_code = str_to_ansi_color(color_string);
+
+        if let Some(output) = ansi_code {
+            Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(color.tag()),
+            )))
+        } else {
+            Err(ShellError::labeled_error(
+                "Unknown color",
+                "unknown color",
+                color.tag(),
+            ))
+        }
+        // }
+    }
+}
+
+pub fn str_to_ansi_color(s: String) -> Option<String> {
+    match s.as_str() {
+        "g" | "green" => Some(Color::Green.prefix().to_string()),
+        "gb" | "green_bold" => Some(Color::Green.bold().prefix().to_string()),
+        "gu" | "green_underline" => Some(Color::Green.underline().prefix().to_string()),
+        "gi" | "green_italic" => Some(Color::Green.italic().prefix().to_string()),
+        "gd" | "green_dimmed" => Some(Color::Green.dimmed().prefix().to_string()),
+        "gr" | "green_reverse" => Some(Color::Green.reverse().prefix().to_string()),
+        "r" | "red" => Some(Color::Red.prefix().to_string()),
+        "rb" | "red_bold" => Some(Color::Red.bold().prefix().to_string()),
+        "ru" | "red_underline" => Some(Color::Red.underline().prefix().to_string()),
+        "ri" | "red_italic" => Some(Color::Red.italic().prefix().to_string()),
+        "rd" | "red_dimmed" => Some(Color::Red.dimmed().prefix().to_string()),
+        "rr" | "red_reverse" => Some(Color::Red.reverse().prefix().to_string()),
+        "u" | "blue" => Some(Color::Blue.prefix().to_string()),
+        "ub" | "blue_bold" => Some(Color::Blue.bold().prefix().to_string()),
+        "uu" | "blue_underline" => Some(Color::Blue.underline().prefix().to_string()),
+        "ui" | "blue_italic" => Some(Color::Blue.italic().prefix().to_string()),
+        "ud" | "blue_dimmed" => Some(Color::Blue.dimmed().prefix().to_string()),
+        "ur" | "blue_reverse" => Some(Color::Blue.reverse().prefix().to_string()),
+        "b" | "black" => Some(Color::Black.prefix().to_string()),
+        "bb" | "black_bold" => Some(Color::Black.bold().prefix().to_string()),
+        "bu" | "black_underline" => Some(Color::Black.underline().prefix().to_string()),
+        "bi" | "black_italic" => Some(Color::Black.italic().prefix().to_string()),
+        "bd" | "black_dimmed" => Some(Color::Black.dimmed().prefix().to_string()),
+        "br" | "black_reverse" => Some(Color::Black.reverse().prefix().to_string()),
+        "y" | "yellow" => Some(Color::Yellow.prefix().to_string()),
+        "yb" | "yellow_bold" => Some(Color::Yellow.bold().prefix().to_string()),
+        "yu" | "yellow_underline" => Some(Color::Yellow.underline().prefix().to_string()),
+        "yi" | "yellow_italic" => Some(Color::Yellow.italic().prefix().to_string()),
+        "yd" | "yellow_dimmed" => Some(Color::Yellow.dimmed().prefix().to_string()),
+        "yr" | "yellow_reverse" => Some(Color::Yellow.reverse().prefix().to_string()),
+        "p" | "purple" => Some(Color::Purple.prefix().to_string()),
+        "pb" | "purple_bold" => Some(Color::Purple.bold().prefix().to_string()),
+        "pu" | "purple_underline" => Some(Color::Purple.underline().prefix().to_string()),
+        "pi" | "purple_italic" => Some(Color::Purple.italic().prefix().to_string()),
+        "pd" | "purple_dimmed" => Some(Color::Purple.dimmed().prefix().to_string()),
+        "pr" | "purple_reverse" => Some(Color::Purple.reverse().prefix().to_string()),
+        "c" | "cyan" => Some(Color::Cyan.prefix().to_string()),
+        "cb" | "cyan_bold" => Some(Color::Cyan.bold().prefix().to_string()),
+        "cu" | "cyan_underline" => Some(Color::Cyan.underline().prefix().to_string()),
+        "ci" | "cyan_italic" => Some(Color::Cyan.italic().prefix().to_string()),
+        "cd" | "cyan_dimmed" => Some(Color::Cyan.dimmed().prefix().to_string()),
+        "cr" | "cyan_reverse" => Some(Color::Cyan.reverse().prefix().to_string()),
+        "w" | "white" => Some(Color::White.prefix().to_string()),
+        "wb" | "white_bold" => Some(Color::White.bold().prefix().to_string()),
+        "wu" | "white_underline" => Some(Color::White.underline().prefix().to_string()),
+        "wi" | "white_italic" => Some(Color::White.italic().prefix().to_string()),
+        "wd" | "white_dimmed" => Some(Color::White.dimmed().prefix().to_string()),
+        "wr" | "white_reverse" => Some(Color::White.reverse().prefix().to_string()),
+        "reset" => Some("\x1b[0m".to_owned()),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Ansi;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Ansi {})?)
+    }
+}

crates/nu-command/src/commands/append.rs

@@ -0,0 +1,85 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+#[derive(Deserialize)]
+struct Arguments {
+    value: Value,
+}
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "append"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("append").required(
+            "row value",
+            SyntaxShape::Any,
+            "the value of the row to append to the table",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Append a row to the table"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let (Arguments { mut value }, input) = args.process().await?;
+
+        let input: Vec<Value> = input.collect().await;
+
+        if let Some(first) = input.get(0) {
+            value.tag = first.tag();
+        }
+
+        // Checks if we are trying to append a row literal
+        if let Value {
+            value: UntaggedValue::Table(values),
+            tag,
+        } = &value
+        {
+            if values.len() == 1 && values[0].is_row() {
+                value = values[0].value.clone().into_value(tag);
+            }
+        }
+
+        Ok(futures::stream::iter(
+            input
+                .into_iter()
+                .chain(vec![value])
+                .map(ReturnSuccess::value),
+        )
+        .to_output_stream())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        use nu_protocol::row;
+
+        vec![
+            Example {
+                description: "Add values to the end of the table",
+                example: "echo [1 2 3] | append 4",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(2).into(),
+                    UntaggedValue::int(3).into(),
+                    UntaggedValue::int(4).into(),
+                ]),
+            },
+            Example {
+                description: "Add row value to the end of the table",
+                example: "echo [[country]; [Ecuador] ['New Zealand']] | append [[country]; [USA]]",
+                result: Some(vec![
+                    row! { "country".into() => Value::from("Ecuador")},
+                    row! { "country".into() => Value::from("New Zealand")},
+                    row! { "country".into() => Value::from("USA")},
+                ]),
+            },
+        ]
+    }
+}

crates/nu-command/src/commands/args.rs

@@ -0,0 +1,10 @@
+use nu_protocol::Value;
+
+#[derive(Debug)]
+pub enum LogLevel {}
+
+#[derive(Debug)]
+pub struct LogItem {
+    level: LogLevel,
+    value: Value,
+}

crates/nu-command/src/commands/autoenv.rs

@@ -0,0 +1,86 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+use serde::Deserialize;
+use serde::Serialize;
+use sha2::{Digest, Sha256};
+use std::io::Read;
+use std::path::PathBuf;
+pub struct Autoenv;
+
+#[derive(Deserialize, Serialize, Debug, Default)]
+pub struct Trusted {
+    pub files: IndexMap<String, Vec<u8>>,
+}
+impl Trusted {
+    pub fn new() -> Self {
+        Trusted {
+            files: IndexMap::new(),
+        }
+    }
+}
+pub fn file_is_trusted(nu_env_file: &PathBuf, content: &[u8]) -> Result<bool, ShellError> {
+    let contentdigest = Sha256::digest(&content).as_slice().to_vec();
+    let nufile = std::fs::canonicalize(nu_env_file)?;
+
+    let trusted = read_trusted()?;
+    Ok(trusted.files.get(&nufile.to_string_lossy().to_string()) == Some(&contentdigest))
+}
+
+pub fn read_trusted() -> Result<Trusted, ShellError> {
+    let config_path = config::default_path_for(&Some(PathBuf::from("nu-env.toml")))?;
+
+    let mut file = std::fs::OpenOptions::new()
+        .read(true)
+        .create(true)
+        .write(true)
+        .open(config_path)
+        .map_err(|_| ShellError::untagged_runtime_error("Couldn't open nu-env.toml"))?;
+    let mut doc = String::new();
+    file.read_to_string(&mut doc)?;
+
+    let allowed = toml::de::from_str(doc.as_str()).unwrap_or_else(|_| Trusted::new());
+    Ok(allowed)
+}
+
+#[async_trait]
+impl WholeStreamCommand for Autoenv {
+    fn name(&self) -> &str {
+        "autoenv"
+    }
+    fn usage(&self) -> &str {
+        // "Mark a .nu-env file in a directory as trusted. Needs to be re-run after each change to the file or its filepath."
+        r#"Manage directory specific environment variables and scripts. Create a file called .nu-env in any directory and run 'autoenv trust' to let nushell read it when entering the directory.
+The file can contain several optional sections:
+    env: environment variables to set when visiting the directory. The variables are unset after leaving the directory and any overwritten values are restored.
+    scriptvars: environment variables that should be set to the return value of a script. After they have been set, they behave in the same way as variables set in the env section.
+    scripts: scripts to run when entering the directory or leaving it."#
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("autoenv")
+    }
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(get_help(&Autoenv, &args.scope)).into_value(Tag::unknown()),
+        )))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Example .nu-env file",
+            example: r#"cat .nu-env
+        [env]
+        mykey = "myvalue"
+
+        [scriptvars]
+        myscript = "echo myval"
+
+        [scripts]
+        entryscripts = ["touch hello.txt", "touch hello2.txt"]
+        exitscripts = ["touch bye.txt"]"#,
+            result: None,
+        }]
+    }
+}

crates/nu-command/src/commands/autoenv_trust.rs

@@ -0,0 +1,80 @@
+use super::autoenv::read_trusted;
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::SyntaxShape;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+use sha2::{Digest, Sha256};
+use std::{fs, path::PathBuf};
+pub struct AutoenvTrust;
+
+#[async_trait]
+impl WholeStreamCommand for AutoenvTrust {
+    fn name(&self) -> &str {
+        "autoenv trust"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("autoenv trust").optional("dir", SyntaxShape::String, "Directory to allow")
+    }
+
+    fn usage(&self) -> &str {
+        "Trust a .nu-env file in the current or given directory"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let ctx = EvaluationContext::from_args(&args);
+
+        let file_to_trust = match args.call_info.evaluate(&ctx).await?.args.nth(0) {
+            Some(Value {
+                value: UntaggedValue::Primitive(Primitive::String(ref path)),
+                tag: _,
+            }) => {
+                let mut dir = fs::canonicalize(path)?;
+                dir.push(".nu-env");
+                dir
+            }
+            _ => {
+                let mut dir = fs::canonicalize(std::env::current_dir()?)?;
+                dir.push(".nu-env");
+                dir
+            }
+        };
+
+        let content = std::fs::read(&file_to_trust)?;
+
+        let filename = file_to_trust.to_string_lossy().to_string();
+        let mut allowed = read_trusted()?;
+        allowed
+            .files
+            .insert(filename, Sha256::digest(&content).as_slice().to_vec());
+
+        let config_path = config::default_path_for(&Some(PathBuf::from("nu-env.toml")))?;
+        let tomlstr = toml::to_string(&allowed).map_err(|_| {
+            ShellError::untagged_runtime_error("Couldn't serialize allowed dirs to nu-env.toml")
+        })?;
+        fs::write(config_path, tomlstr).expect("Couldn't write to toml file");
+
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(".nu-env trusted!").into_value(tag),
+        )))
+    }
+    fn is_binary(&self) -> bool {
+        false
+    }
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Allow .nu-env file in current directory",
+                example: "autoenv trust",
+                result: None,
+            },
+            Example {
+                description: "Allow .nu-env file in directory foo",
+                example: "autoenv trust foo",
+                result: None,
+            },
+        ]
+    }
+}

crates/nu-command/src/commands/autoenv_untrust.rs

@@ -0,0 +1,104 @@
+use super::autoenv::Trusted;
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::SyntaxShape;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+use std::io::Read;
+use std::{fs, path::PathBuf};
+pub struct AutoenvUnTrust;
+
+#[async_trait]
+impl WholeStreamCommand for AutoenvUnTrust {
+    fn name(&self) -> &str {
+        "autoenv untrust"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("autoenv untrust").optional(
+            "dir",
+            SyntaxShape::String,
+            "Directory to disallow",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Untrust a .nu-env file in the current or given directory"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let ctx = EvaluationContext::from_args(&args);
+        let file_to_untrust = match args.call_info.evaluate(&ctx).await?.args.nth(0) {
+            Some(Value {
+                value: UntaggedValue::Primitive(Primitive::String(ref path)),
+                tag: _,
+            }) => {
+                let mut dir = fs::canonicalize(path)?;
+                dir.push(".nu-env");
+                dir
+            }
+            _ => {
+                let mut dir = std::env::current_dir()?;
+                dir.push(".nu-env");
+                dir
+            }
+        };
+
+        let config_path = config::default_path_for(&Some(PathBuf::from("nu-env.toml")))?;
+
+        let mut file = match std::fs::OpenOptions::new()
+            .read(true)
+            .create(true)
+            .write(true)
+            .open(config_path.clone())
+        {
+            Ok(p) => p,
+            Err(_) => {
+                return Err(ShellError::untagged_runtime_error(
+                    "Couldn't open nu-env.toml",
+                ));
+            }
+        };
+
+        let mut doc = String::new();
+        file.read_to_string(&mut doc)?;
+
+        let mut allowed: Trusted = toml::from_str(doc.as_str()).unwrap_or_else(|_| Trusted::new());
+
+        let file_to_untrust = file_to_untrust.to_string_lossy().to_string();
+
+        if allowed.files.remove(&file_to_untrust).is_none() {
+            return
+                Err(ShellError::untagged_runtime_error(
+                    "No .nu-env file to untrust in the given directory. Is it missing, or already untrusted?",
+                ));
+        }
+
+        let tomlstr = toml::to_string(&allowed).map_err(|_| {
+            ShellError::untagged_runtime_error("Couldn't serialize allowed dirs to nu-env.toml")
+        })?;
+        fs::write(config_path, tomlstr).expect("Couldn't write to toml file");
+
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(".nu-env untrusted!").into_value(tag),
+        )))
+    }
+    fn is_binary(&self) -> bool {
+        false
+    }
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Disallow .nu-env file in current directory",
+                example: "autoenv untrust",
+                result: None,
+            },
+            Example {
+                description: "Disallow .nu-env file in directory foo",
+                example: "autoenv untrust foo",
+                result: None,
+            },
+        ]
+    }
+}

crates/nu-command/src/commands/autoview/command.rs

@@ -0,0 +1,314 @@
+use crate::commands::autoview::options::{ConfigExtensions, NuConfig as AutoViewConfiguration};
+use crate::prelude::*;
+use crate::primitive::get_color_config;
+use nu_data::value::format_leaf;
+use nu_engine::{UnevaluatedCallInfo, WholeStreamCommand};
+use nu_errors::ShellError;
+use nu_protocol::hir::{self, Expression, ExternalRedirection, Literal, SpannedExpression};
+use nu_protocol::{Primitive, Signature, UntaggedValue, Value};
+use nu_table::TextStyle;
+use parking_lot::Mutex;
+use std::sync::atomic::AtomicBool;
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "autoview"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("autoview")
+    }
+
+    fn usage(&self) -> &str {
+        "View the contents of the pipeline as a table or list."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        autoview(RunnableContext {
+            input: args.input,
+            scope: args.scope.clone(),
+            shell_manager: args.shell_manager,
+            host: args.host,
+            ctrl_c: args.ctrl_c,
+            current_errors: args.current_errors,
+            name: args.call_info.name_tag,
+        })
+        .await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Automatically view the results",
+                example: "ls | autoview",
+                result: None,
+            },
+            Example {
+                description: "Autoview is also implied. The above can be written as",
+                example: "ls",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub struct RunnableContextWithoutInput {
+    pub shell_manager: ShellManager,
+    pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
+    pub current_errors: Arc<Mutex<Vec<ShellError>>>,
+    pub ctrl_c: Arc<AtomicBool>,
+    pub scope: Scope,
+    pub name: Tag,
+}
+
+impl RunnableContextWithoutInput {
+    pub fn convert(context: RunnableContext) -> (InputStream, RunnableContextWithoutInput) {
+        let new_context = RunnableContextWithoutInput {
+            shell_manager: context.shell_manager,
+            host: context.host,
+            ctrl_c: context.ctrl_c,
+            current_errors: context.current_errors,
+            scope: context.scope,
+            name: context.name,
+        };
+        (context.input, new_context)
+    }
+}
+
+pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellError> {
+    let configuration = AutoViewConfiguration::new();
+
+    let binary = context.get_command("binaryview");
+    let text = context.get_command("textview");
+    let table = context.get_command("table");
+
+    let pivot_mode = configuration.pivot_mode();
+
+    let (mut input_stream, context) = RunnableContextWithoutInput::convert(context);
+    let term_width = context.host.lock().width();
+    let color_hm = get_color_config();
+
+    if let Some(x) = input_stream.next().await {
+        match input_stream.next().await {
+            Some(y) => {
+                let ctrl_c = context.ctrl_c.clone();
+                let xy = vec![x, y];
+                let xy_stream = futures::stream::iter(xy)
+                    .chain(input_stream)
+                    .interruptible(ctrl_c);
+
+                let stream = InputStream::from_stream(xy_stream);
+
+                if let Some(table) = table {
+                    let command_args = create_default_command_args(&context).with_input(stream);
+                    let result = table.run(command_args).await?;
+                    result.collect::<Vec<_>>().await;
+                }
+            }
+            _ => {
+                match x {
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::String(ref s)),
+                        tag: Tag { anchor, span },
+                    } if anchor.is_some() => {
+                        if let Some(text) = text {
+                            let mut stream = VecDeque::new();
+                            stream.push_back(
+                                UntaggedValue::string(s).into_value(Tag { anchor, span }),
+                            );
+                            let command_args =
+                                create_default_command_args(&context).with_input(stream);
+                            let result = text.run(command_args).await?;
+                            result.collect::<Vec<_>>().await;
+                        } else {
+                            out!("{}", s);
+                        }
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::String(s)),
+                        ..
+                    } => {
+                        out!("{}", s);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::FilePath(s)),
+                        ..
+                    } => {
+                        out!("{}", s.display());
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Int(n)),
+                        ..
+                    } => {
+                        out!("{}", n);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Decimal(n)),
+                        ..
+                    } => {
+                        // TODO: normalize decimal to remove trailing zeros.
+                        // normalization will be available in next release of bigdecimal crate
+                        let mut output = n.to_string();
+                        if output.contains('.') {
+                            output = output.trim_end_matches('0').to_owned();
+                        }
+                        if output.ends_with('.') {
+                            output.push('0');
+                        }
+                        out!("{}", output);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Boolean(b)),
+                        ..
+                    } => {
+                        out!("{}", b);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Duration(_)),
+                        ..
+                    } => {
+                        let output = format_leaf(&x).plain_string(100_000);
+                        out!("{}", output);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Date(d)),
+                        ..
+                    } => {
+                        out!("{}", d);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Range(_)),
+                        ..
+                    } => {
+                        let output = format_leaf(&x).plain_string(100_000);
+                        out!("{}", output);
+                    }
+
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Binary(ref b)),
+                        ..
+                    } => {
+                        if let Some(binary) = binary {
+                            let mut stream = VecDeque::new();
+                            stream.push_back(x);
+                            let command_args =
+                                create_default_command_args(&context).with_input(stream);
+                            let result = binary.run(command_args).await?;
+                            result.collect::<Vec<_>>().await;
+                        } else {
+                            use pretty_hex::*;
+                            out!("{:?}", b.hex_dump());
+                        }
+                    }
+
+                    Value {
+                        value: UntaggedValue::Error(e),
+                        ..
+                    } => {
+                        return Err(e);
+                    }
+
+                    Value {
+                        value: UntaggedValue::Row(row),
+                        ..
+                    } if pivot_mode.is_always()
+                        || (pivot_mode.is_auto()
+                            && (row
+                                .entries
+                                .iter()
+                                .map(|(_, v)| v.convert_to_string())
+                                .collect::<Vec<_>>()
+                                .iter()
+                                .fold(0usize, |acc, len| acc + len.len())
+                                + row.entries.iter().count() * 2)
+                                > term_width) =>
+                    {
+                        let mut entries = vec![];
+                        for (key, value) in row.entries.iter() {
+                            entries.push(vec![
+                                nu_table::StyledString::new(
+                                    key.to_string(),
+                                    TextStyle::new()
+                                        .alignment(nu_table::Alignment::Left)
+                                        .fg(ansi_term::Color::Green)
+                                        .bold(Some(true)),
+                                ),
+                                nu_table::StyledString::new(
+                                    format_leaf(value).plain_string(100_000),
+                                    nu_table::TextStyle::basic_left(),
+                                ),
+                            ]);
+                        }
+
+                        let table =
+                            nu_table::Table::new(vec![], entries, nu_table::Theme::compact());
+
+                        nu_table::draw_table(&table, term_width, &color_hm);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Nothing),
+                        ..
+                    } => {
+                        // Do nothing
+                    }
+                    Value {
+                        value: ref item, ..
+                    } => {
+                        if let Some(table) = table {
+                            let mut stream = VecDeque::new();
+                            stream.push_back(x);
+                            let command_args =
+                                create_default_command_args(&context).with_input(stream);
+                            let result = table.run(command_args).await?;
+                            result.collect::<Vec<_>>().await;
+                        } else {
+                            out!("{:?}", item);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(OutputStream::empty())
+}
+
+fn create_default_command_args(context: &RunnableContextWithoutInput) -> RawCommandArgs {
+    let span = context.name.span;
+    RawCommandArgs {
+        host: context.host.clone(),
+        ctrl_c: context.ctrl_c.clone(),
+        current_errors: context.current_errors.clone(),
+        shell_manager: context.shell_manager.clone(),
+        call_info: UnevaluatedCallInfo {
+            args: hir::Call {
+                head: Box::new(SpannedExpression::new(
+                    Expression::Literal(Literal::String(String::new())),
+                    span,
+                )),
+                positional: None,
+                named: None,
+                span,
+                external_redirection: ExternalRedirection::Stdout,
+            },
+            name_tag: context.name.clone(),
+        },
+        scope: Scope::new(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Command;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Command {})?)
+    }
+}

crates/nu-command/src/commands/autoview/mod.rs

@@ -0,0 +1,4 @@
+pub mod command;
+mod options;
+
+pub use command::Command as Autoview;

crates/nu-command/src/commands/autoview/options.rs

@@ -0,0 +1,51 @@
+pub use nu_data::config::NuConfig;
+use std::fmt::Debug;
+
+#[derive(PartialEq, Debug)]
+pub enum AutoPivotMode {
+    Auto,
+    Always,
+    Never,
+}
+
+impl AutoPivotMode {
+    pub fn is_auto(&self) -> bool {
+        matches!(self, AutoPivotMode::Auto)
+    }
+
+    pub fn is_always(&self) -> bool {
+        matches!(self, AutoPivotMode::Always)
+    }
+
+    #[allow(unused)]
+    pub fn is_never(&self) -> bool {
+        matches!(self, AutoPivotMode::Never)
+    }
+}
+
+pub trait ConfigExtensions: Debug + Send {
+    fn pivot_mode(&self) -> AutoPivotMode;
+}
+
+pub fn pivot_mode(config: &NuConfig) -> AutoPivotMode {
+    let vars = &config.vars;
+
+    if let Some(mode) = vars.get("pivot_mode") {
+        let mode = match mode.as_string() {
+            Ok(m) if m.to_lowercase() == "auto" => AutoPivotMode::Auto,
+            Ok(m) if m.to_lowercase() == "always" => AutoPivotMode::Always,
+            Ok(m) if m.to_lowercase() == "never" => AutoPivotMode::Never,
+            _ => AutoPivotMode::Never,
+        };
+
+        return mode;
+    }
+
+    AutoPivotMode::Never
+}
+
+impl ConfigExtensions for NuConfig {
+    fn pivot_mode(&self) -> AutoPivotMode {
+        pivot_mode(self)
+    }
+}

crates/nu-command/src/commands/benchmark.rs

@@ -0,0 +1,210 @@
+use crate::prelude::*;
+#[cfg(feature = "rich-benchmark")]
+use heim::cpu::time;
+use nu_engine::run_block;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::{Block, CapturedBlock, ClassifiedCommand, Group, InternalCommand, Pipeline},
+    Dictionary, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use rand::{
+    distributions::Alphanumeric,
+    prelude::{thread_rng, Rng},
+};
+use std::convert::TryInto;
+use std::time::{Duration, Instant};
+
+pub struct Benchmark;
+
+#[derive(Deserialize, Debug)]
+struct BenchmarkArgs {
+    block: CapturedBlock,
+    passthrough: Option<CapturedBlock>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Benchmark {
+    fn name(&self) -> &str {
+        "benchmark"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("benchmark")
+            .required(
+                "block",
+                SyntaxShape::Block,
+                "the block to run and benchmark",
+            )
+            .named(
+                "passthrough",
+                SyntaxShape::Block,
+                "Display the benchmark results and pass through the block's output",
+                Some('p'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block and returns the time it took to execute it"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        benchmark(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Benchmarks a command within a block",
+                example: "benchmark { sleep 500ms }",
+                result: None,
+            },
+            Example {
+                description: "Benchmarks a command within a block and passes its output through",
+                example: "echo 45 | benchmark { sleep 500ms } --passthrough {}",
+                result: Some(vec![UntaggedValue::int(45).into()]),
+            },
+        ]
+    }
+}
+
+async fn benchmark(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = raw_args.call_info.args.span;
+    let mut context = EvaluationContext::from_raw(&raw_args);
+    let scope = raw_args.scope.clone();
+    let (BenchmarkArgs { block, passthrough }, input) = raw_args.process().await?;
+
+    let env = scope.get_env_vars();
+    let name = generate_free_name(&env);
+
+    scope.add_env_var(name, generate_random_env_value());
+
+    let start_time = Instant::now();
+
+    #[cfg(feature = "rich-benchmark")]
+    let start = time().await;
+
+    context.scope.enter_scope();
+    let result = run_block(&block.block, &context, input).await;
+    context.scope.exit_scope();
+    let output = result?.into_vec().await;
+
+    #[cfg(feature = "rich-benchmark")]
+    let end = time().await;
+
+    let end_time = Instant::now();
+    context.clear_errors();
+
+    // return basic runtime
+    #[cfg(not(feature = "rich-benchmark"))]
+    {
+        let mut indexmap = IndexMap::with_capacity(1);
+
+        let real_time = into_big_int(end_time - start_time);
+        indexmap.insert("real time".to_string(), real_time);
+        benchmark_output(indexmap, output, passthrough, &tag, &mut context).await
+    }
+    // return advanced stats
+    #[cfg(feature = "rich-benchmark")]
+    if let (Ok(start), Ok(end)) = (start, end) {
+        let mut indexmap = IndexMap::with_capacity(4);
+
+        let real_time = into_big_int(end_time - start_time);
+        indexmap.insert("real time".to_string(), real_time);
+
+        let user_time = into_big_int(end.user() - start.user());
+        indexmap.insert("user time".to_string(), user_time);
+
+        let system_time = into_big_int(end.system() - start.system());
+        indexmap.insert("system time".to_string(), system_time);
+
+        let idle_time = into_big_int(end.idle() - start.idle());
+        indexmap.insert("idle time".to_string(), idle_time);
+
+        benchmark_output(indexmap, output, passthrough, &tag, &mut context).await
+    } else {
+        Err(ShellError::untagged_runtime_error(
+            "Could not retrieve CPU time",
+        ))
+    }
+}
+
+async fn benchmark_output<T, Output>(
+    indexmap: IndexMap<String, BigInt>,
+    block_output: Output,
+    passthrough: Option<CapturedBlock>,
+    tag: T,
+    context: &mut EvaluationContext,
+) -> Result<OutputStream, ShellError>
+where
+    T: Into<Tag> + Copy,
+    Output: Into<OutputStream>,
+{
+    let value = UntaggedValue::Row(Dictionary::from(
+        indexmap
+            .into_iter()
+            .map(|(k, v)| (k, UntaggedValue::duration(v).into_value(tag)))
+            .collect::<IndexMap<String, Value>>(),
+    ))
+    .into_value(tag);
+
+    if let Some(time_block) = passthrough {
+        let benchmark_output = InputStream::one(value);
+
+        // add autoview for an empty block
+        let time_block = add_implicit_autoview(time_block.block);
+
+        context.scope.enter_scope();
+        let result = run_block(&time_block, context, benchmark_output).await;
+        context.scope.exit_scope();
+        result?;
+        context.clear_errors();
+
+        Ok(block_output.into())
+    } else {
+        let benchmark_output = OutputStream::one(value);
+        Ok(benchmark_output)
+    }
+}
+
+fn add_implicit_autoview(mut block: Block) -> Block {
+    if block.block.is_empty() {
+        let group = Group::new(
+            vec![{
+                let mut commands = Pipeline::new(block.span);
+                commands.push(ClassifiedCommand::Internal(InternalCommand::new(
+                    "autoview".to_string(),
+                    block.span,
+                    block.span,
+                )));
+                commands
+            }],
+            block.span,
+        );
+        block.push(group);
+    }
+    block
+}
+
+fn into_big_int<T: TryInto<Duration>>(time: T) -> BigInt {
+    time.try_into()
+        .unwrap_or_else(|_| Duration::new(0, 0))
+        .as_nanos()
+        .into()
+}
+
+fn generate_random_env_value() -> String {
+    let mut thread_rng = thread_rng();
+    let len = thread_rng.gen_range(1, 16 * 1024);
+    thread_rng.sample_iter(&Alphanumeric).take(len).collect()
+}
+
+fn generate_free_name(env: &indexmap::IndexMap<String, String>) -> String {
+    let mut thread_rng = thread_rng();
+    loop {
+        let candidate_name = format!("NU_RANDOM_VALUE_{}", thread_rng.gen::<usize>());
+        if !env.contains_key(&candidate_name) {
+            return candidate_name;
+        }
+    }
+}

crates/nu-command/src/commands/build_string.rs

@@ -0,0 +1,52 @@
+use crate::prelude::*;
+use nu_errors::ShellError;
+
+use nu_data::value::format_leaf;
+use nu_engine::WholeStreamCommand;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+#[derive(Deserialize)]
+pub struct BuildStringArgs {
+    rest: Vec<Value>,
+}
+
+pub struct BuildString;
+
+#[async_trait]
+impl WholeStreamCommand for BuildString {
+    fn name(&self) -> &str {
+        "build-string"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("build-string")
+            .rest(SyntaxShape::Any, "all values to form into the string")
+    }
+
+    fn usage(&self) -> &str {
+        "Builds a string from the arguments"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let (BuildStringArgs { rest }, _) = args.process().await?;
+
+        let mut output_string = String::new();
+
+        for r in rest {
+            output_string.push_str(&format_leaf(&r).plain_string(100_000))
+        }
+
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(output_string).into_value(tag),
+        )))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Builds a string from a string and a number, without spaces between them",
+            example: "build-string 'foo' 3",
+            result: None,
+        }]
+    }
+}

crates/nu-command/src/commands/cal.rs

@@ -0,0 +1,342 @@
+use crate::prelude::*;
+use chrono::{Datelike, Local, NaiveDate};
+use indexmap::IndexMap;
+use nu_engine::{EvaluatedWholeStreamCommandArgs, WholeStreamCommand};
+use nu_errors::ShellError;
+use nu_protocol::{Dictionary, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct Cal;
+
+#[async_trait]
+impl WholeStreamCommand for Cal {
+    fn name(&self) -> &str {
+        "cal"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("cal")
+            .switch("year", "Display the year column", Some('y'))
+            .switch("quarter", "Display the quarter column", Some('q'))
+            .switch("month", "Display the month column", Some('m'))
+            .named(
+                "full-year",
+                SyntaxShape::Int,
+                "Display a year-long calendar for the specified year",
+                None,
+            )
+            .named(
+                "week-start",
+                SyntaxShape::String,
+                "Display the calendar with the specified day as the first day of the week",
+                None,
+            )
+            .switch(
+                "month-names",
+                "Display the month names instead of integers",
+                None,
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Display a calendar."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        cal(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "This month's calendar",
+                example: "cal",
+                result: None,
+            },
+            Example {
+                description: "The calendar for all of 2012",
+                example: "cal --full-year 2012",
+                result: None,
+            },
+            Example {
+                description: "This month's calendar with the week starting on monday",
+                example: "cal --week-start monday",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn cal(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let mut calendar_vec_deque = VecDeque::new();
+    let tag = args.call_info.name_tag.clone();
+
+    let (current_year, current_month, current_day) = get_current_date();
+
+    let mut selected_year: i32 = current_year;
+    let mut current_day_option: Option<u32> = Some(current_day);
+
+    let month_range = if let Some(full_year_value) = args.get("full-year") {
+        if let Ok(year_u64) = full_year_value.as_u64() {
+            selected_year = year_u64 as i32;
+
+            if selected_year != current_year {
+                current_day_option = None
+            }
+        } else {
+            return Err(get_invalid_year_shell_error(&full_year_value.tag()));
+        }
+
+        (1, 12)
+    } else {
+        (current_month, current_month)
+    };
+
+    add_months_of_year_to_table(
+        &args,
+        &mut calendar_vec_deque,
+        &tag,
+        selected_year,
+        month_range,
+        current_month,
+        current_day_option,
+    )?;
+
+    Ok(futures::stream::iter(calendar_vec_deque).to_output_stream())
+}
+
+fn get_invalid_year_shell_error(year_tag: &Tag) -> ShellError {
+    ShellError::labeled_error("The year is invalid", "invalid year", year_tag)
+}
+
+struct MonthHelper {
+    selected_year: i32,
+    selected_month: u32,
+    day_number_of_week_month_starts_on: u32,
+    number_of_days_in_month: u32,
+    quarter_number: u32,
+    month_name: String,
+}
+
+impl MonthHelper {
+    pub fn new(selected_year: i32, selected_month: u32) -> Result<MonthHelper, ()> {
+        let naive_date = NaiveDate::from_ymd_opt(selected_year, selected_month, 1).ok_or(())?;
+        let number_of_days_in_month =
+            MonthHelper::calculate_number_of_days_in_month(selected_year, selected_month)?;
+
+        Ok(MonthHelper {
+            selected_year,
+            selected_month,
+            day_number_of_week_month_starts_on: naive_date.weekday().num_days_from_sunday(),
+            number_of_days_in_month,
+            quarter_number: ((selected_month - 1) / 3) + 1,
+            month_name: naive_date.format("%B").to_string().to_ascii_lowercase(),
+        })
+    }
+
+    fn calculate_number_of_days_in_month(
+        mut selected_year: i32,
+        mut selected_month: u32,
+    ) -> Result<u32, ()> {
+        // Chrono does not provide a method to output the amount of days in a month
+        // This is a workaround taken from the example code from the Chrono docs here:
+        // https://docs.rs/chrono/0.3.0/chrono/naive/date/struct.NaiveDate.html#example-30
+        if selected_month == 12 {
+            selected_year += 1;
+            selected_month = 1;
+        } else {
+            selected_month += 1;
+        };
+
+        let next_month_naive_date =
+            NaiveDate::from_ymd_opt(selected_year, selected_month, 1).ok_or(())?;
+
+        Ok(next_month_naive_date.pred().day())
+    }
+}
+
+fn get_current_date() -> (i32, u32, u32) {
+    let local_now_date = Local::now().date();
+
+    let current_year: i32 = local_now_date.year();
+    let current_month: u32 = local_now_date.month();
+    let current_day: u32 = local_now_date.day();
+
+    (current_year, current_month, current_day)
+}
+
+fn add_months_of_year_to_table(
+    args: &EvaluatedWholeStreamCommandArgs,
+    mut calendar_vec_deque: &mut VecDeque<Value>,
+    tag: &Tag,
+    selected_year: i32,
+    (start_month, end_month): (u32, u32),
+    current_month: u32,
+    current_day_option: Option<u32>,
+) -> Result<(), ShellError> {
+    for month_number in start_month..=end_month {
+        let mut new_current_day_option: Option<u32> = None;
+
+        if let Some(current_day) = current_day_option {
+            if month_number == current_month {
+                new_current_day_option = Some(current_day)
+            }
+        }
+
+        let add_month_to_table_result = add_month_to_table(
+            &args,
+            &mut calendar_vec_deque,
+            &tag,
+            selected_year,
+            month_number,
+            new_current_day_option,
+        );
+
+        add_month_to_table_result?
+    }
+
+    Ok(())
+}
+
+fn add_month_to_table(
+    args: &EvaluatedWholeStreamCommandArgs,
+    calendar_vec_deque: &mut VecDeque<Value>,
+    tag: &Tag,
+    selected_year: i32,
+    current_month: u32,
+    current_day_option: Option<u32>,
+) -> Result<(), ShellError> {
+    let month_helper_result = MonthHelper::new(selected_year, current_month);
+
+    let month_helper = match month_helper_result {
+        Ok(month_helper) => month_helper,
+        Err(()) => match args.get("full-year") {
+            Some(full_year_value) => {
+                return Err(get_invalid_year_shell_error(&full_year_value.tag()))
+            }
+            None => {
+                return Err(ShellError::labeled_error(
+                    "Issue parsing command",
+                    "invalid command",
+                    tag,
+                ))
+            }
+        },
+    };
+
+    let mut days_of_the_week = [
+        "sunday",
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+    ];
+
+    let mut week_start_day = days_of_the_week[0].to_string();
+
+    if let Some(week_start_value) = args.get("week-start") {
+        if let Ok(day) = week_start_value.as_string() {
+            if days_of_the_week.contains(&day.as_str()) {
+                week_start_day = day;
+            } else {
+                return Err(ShellError::labeled_error(
+                    "The specified week start day is invalid",
+                    "invalid week start day",
+                    week_start_value.tag(),
+                ));
+            }
+        }
+    }
+
+    let week_start_day_offset = days_of_the_week.len()
+        - days_of_the_week
+            .iter()
+            .position(|day| *day == week_start_day)
+            .unwrap_or(0);
+
+    days_of_the_week.rotate_right(week_start_day_offset);
+
+    let mut total_start_offset: u32 =
+        month_helper.day_number_of_week_month_starts_on + week_start_day_offset as u32;
+    total_start_offset %= days_of_the_week.len() as u32;
+
+    let mut day_number: u32 = 1;
+    let day_limit: u32 = total_start_offset + month_helper.number_of_days_in_month;
+
+    let should_show_year_column = args.has("year");
+    let should_show_quarter_column = args.has("quarter");
+    let should_show_month_column = args.has("month");
+    let should_show_month_names = args.has("month-names");
+
+    while day_number <= day_limit {
+        let mut indexmap = IndexMap::new();
+
+        if should_show_year_column {
+            indexmap.insert(
+                "year".to_string(),
+                UntaggedValue::int(month_helper.selected_year).into_value(tag),
+            );
+        }
+
+        if should_show_quarter_column {
+            indexmap.insert(
+                "quarter".to_string(),
+                UntaggedValue::int(month_helper.quarter_number).into_value(tag),
+            );
+        }
+
+        if should_show_month_column || should_show_month_names {
+            let month_value = if should_show_month_names {
+                UntaggedValue::string(month_helper.month_name.clone()).into_value(tag)
+            } else {
+                UntaggedValue::int(month_helper.selected_month).into_value(tag)
+            };
+
+            indexmap.insert("month".to_string(), month_value);
+        }
+
+        for day in &days_of_the_week {
+            let should_add_day_number_to_table =
+                (day_number > total_start_offset) && (day_number <= day_limit);
+
+            let mut value = UntaggedValue::nothing().into_value(tag);
+
+            if should_add_day_number_to_table {
+                let adjusted_day_number = day_number - total_start_offset;
+
+                value = UntaggedValue::int(adjusted_day_number).into_value(tag);
+
+                if let Some(current_day) = current_day_option {
+                    if current_day == adjusted_day_number {
+                        // TODO: Update the value here with a color when color support is added
+                        // This colors the current day
+                    }
+                }
+            }
+
+            indexmap.insert((*day).to_string(), value);
+
+            day_number += 1;
+        }
+
+        calendar_vec_deque
+            .push_back(UntaggedValue::Row(Dictionary::from(indexmap)).into_value(tag));
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Cal;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Cal {})?)
+    }
+}

crates/nu-command/src/commands/cd.rs

@@ -0,0 +1,72 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+
+use nu_engine::shell::CdArgs;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape};
+
+pub struct Cd;
+
+#[async_trait]
+impl WholeStreamCommand for Cd {
+    fn name(&self) -> &str {
+        "cd"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("cd").optional(
+            "directory",
+            SyntaxShape::FilePath,
+            "the directory to change to",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Change to a new path."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let name = args.call_info.name_tag.clone();
+        let shell_manager = args.shell_manager.clone();
+        let (args, _): (CdArgs, _) = args.process().await?;
+        shell_manager.cd(args, name)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Change to a new directory called 'dirname'",
+                example: "cd dirname",
+                result: None,
+            },
+            Example {
+                description: "Change to your home directory",
+                example: "cd",
+                result: None,
+            },
+            Example {
+                description: "Change to your home directory (alternate version)",
+                example: "cd ~",
+                result: None,
+            },
+            Example {
+                description: "Change to the previous directory",
+                example: "cd -",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Cd;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Cd {})?)
+    }
+}

crates/nu-command/src/commands/char_.rs

@@ -0,0 +1,166 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct Char;
+
+#[derive(Deserialize)]
+struct CharArgs {
+    name: Tagged<String>,
+    unicode: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Char {
+    fn name(&self) -> &str {
+        "char"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("ansi")
+            .required(
+                "character",
+                SyntaxShape::Any,
+                "the name of the character to output",
+            )
+            .switch("unicode", "unicode string i.e. 1f378", Some('u'))
+    }
+
+    fn usage(&self) -> &str {
+        "Output special characters (eg. 'newline')"
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Output newline",
+                example: r#"char newline"#,
+                result: Some(vec![Value::from("\n")]),
+            },
+            Example {
+                description: "Output prompt character, newline and a hamburger character",
+                example: r#"echo $(char prompt) $(char newline) $(char hamburger)"#,
+                result: Some(vec![
+                    UntaggedValue::string("\u{25b6}").into(),
+                    UntaggedValue::string("\n").into(),
+                    UntaggedValue::string("\u{2261}").into(),
+                ]),
+            },
+            Example {
+                description: "Output unicode character",
+                example: r#"char -u 1f378"#,
+                result: Some(vec![Value::from("\u{1f378}")]),
+            },
+        ]
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let (CharArgs { name, unicode }, _) = args.process().await?;
+
+        if unicode {
+            let decoded_char = string_to_unicode_char(&name.item);
+            if let Some(output) = decoded_char {
+                Ok(OutputStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(output).into_value(name.tag()),
+                )))
+            } else {
+                Err(ShellError::labeled_error(
+                    "error decoding unicode character",
+                    "error decoding unicode character",
+                    name.tag(),
+                ))
+            }
+        } else {
+            let special_character = str_to_character(&name.item);
+            if let Some(output) = special_character {
+                Ok(OutputStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(output).into_value(name.tag()),
+                )))
+            } else {
+                Err(ShellError::labeled_error(
+                    "error finding named character",
+                    "error finding named character",
+                    name.tag(),
+                ))
+            }
+        }
+    }
+}
+
+fn string_to_unicode_char(s: &str) -> Option<char> {
+    u32::from_str_radix(s, 16)
+        .ok()
+        .and_then(std::char::from_u32)
+}
+
+fn str_to_character(s: &str) -> Option<String> {
+    match s {
+        "newline" | "enter" | "nl" => Some("\n".into()),
+        "tab" => Some("\t".into()),
+        "sp" | "space" => Some(" ".into()),
+        // Unicode names came from https://www.compart.com/en/unicode
+        // Private Use Area (U+E000-U+F8FF)
+        // Unicode can't be mixed with Ansi or it will break width calculation
+        "branch" => Some('\u{e0a0}'.to_string()),  // 
+        "segment" => Some('\u{e0b0}'.to_string()), // 
+
+        "identical_to" | "hamburger" => Some('\u{2261}'.to_string()), // ≡
+        "not_identical_to" | "branch_untracked" => Some('\u{2262}'.to_string()), // ≢
+        "strictly_equivalent_to" | "branch_identical" => Some('\u{2263}'.to_string()), // ≣
+
+        "upwards_arrow" | "branch_ahead" => Some('\u{2191}'.to_string()), // ↑
+        "downwards_arrow" | "branch_behind" => Some('\u{2193}'.to_string()), // ↓
+        "up_down_arrow" | "branch_ahead_behind" => Some('\u{2195}'.to_string()), // ↕
+
+        "black_right_pointing_triangle" | "prompt" => Some('\u{25b6}'.to_string()), // ▶
+        "vector_or_cross_product" | "failed" => Some('\u{2a2f}'.to_string()),       // ⨯
+        "high_voltage_sign" | "elevated" => Some('\u{26a1}'.to_string()),           // ⚡
+        "tilde" | "twiddle" | "squiggly" | "home" => Some("~".into()),              // ~
+        "hash" | "hashtag" | "pound_sign" | "sharp" | "root" => Some("#".into()),   // #
+
+        // Weather symbols
+        "sun" | "sunny" | "sunrise" => Some("☀️".to_string()),
+        "moon" => Some("🌛".to_string()),
+        "cloudy" | "cloud" | "clouds" => Some("☁️".to_string()),
+        "rainy" | "rain" => Some("🌦️".to_string()),
+        "foggy" | "fog" => Some("🌫️".to_string()),
+        "mist" | "haze" => Some("\u{2591}".to_string()),
+        "snowy" | "snow" => Some("❄️".to_string()),
+        "thunderstorm" | "thunder" => Some("🌩️".to_string()),
+
+        // Reference for ansi codes https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797
+        // Another good reference http://ascii-table.com/ansi-escape-sequences.php
+
+        // For setting title like `echo [$(char title) $(pwd) $(char bel)] | str collect`
+        "title" => Some("\x1b]2;".to_string()), // ESC]2; xterm sets window title
+        "bel" => Some('\x07'.to_string()),      // Terminal Bell
+        "backspace" => Some('\x08'.to_string()), // Backspace
+
+        // Ansi Erase Sequences
+        "clear_screen" => Some("\x1b[J".to_string()), // clears the screen
+        "clear_screen_from_cursor_to_end" => Some("\x1b[0J".to_string()), // clears from cursor until end of screen
+        "clear_screen_from_cursor_to_beginning" => Some("\x1b[1J".to_string()), // clears from cursor to beginning of screen
+        "cls" | "clear_entire_screen" => Some("\x1b[2J".to_string()), // clears the entire screen
+        "erase_line" => Some("\x1b[K".to_string()),                   // clears the current line
+        "erase_line_from_cursor_to_end" => Some("\x1b[0K".to_string()), // clears from cursor to end of line
+        "erase_line_from_cursor_to_beginning" => Some("\x1b[1K".to_string()), // clears from cursor to start of line
+        "erase_entire_line" => Some("\x1b[2K".to_string()),                   // clears entire line
+
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Char;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Char {})?)
+    }
+}

crates/nu-command/src/commands/chart.rs

@@ -0,0 +1,47 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+#[derive(Clone)]
+pub struct Chart;
+
+#[async_trait]
+impl WholeStreamCommand for Chart {
+    fn name(&self) -> &str {
+        "chart"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("chart")
+    }
+
+    fn usage(&self) -> &str {
+        "Displays charts."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        if args.scope.get_command("chart bar").is_none() {
+            return Err(ShellError::untagged_runtime_error(
+                "nu_plugin_chart not installed.",
+            ));
+        }
+
+        Ok(OutputStream::one(Ok(ReturnSuccess::Value(
+            UntaggedValue::string(get_help(&Chart, &args.scope)).into_value(Tag::unknown()),
+        ))))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Chart;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Chart {})?)
+    }
+}

crates/nu-command/src/commands/classified/dynamic.rs

@@ -0,0 +1,7 @@
+use derive_new::new;
+use nu_protocol::hir;
+
+#[derive(new, Debug)]
+pub(crate) struct Command {
+    pub(crate) args: hir::Call,
+}

crates/nu-command/src/commands/classified/external.rs

@@ -0,0 +1,682 @@
+use crate::futures::ThreadedReceiver;
+use crate::prelude::*;
+use nu_engine::evaluate_baseline_expr;
+use nu_engine::{MaybeTextCodec, StringOrBinary};
+
+use std::borrow::Cow;
+use std::io::Write;
+use std::ops::Deref;
+use std::process::{Command, Stdio};
+use std::sync::mpsc;
+
+use futures::executor::block_on_stream;
+use futures_codec::FramedRead;
+use log::trace;
+
+use nu_errors::ShellError;
+use nu_protocol::hir::Expression;
+use nu_protocol::hir::{ExternalCommand, ExternalRedirection};
+use nu_protocol::{Primitive, ShellTypeName, UntaggedValue, Value};
+use nu_source::Tag;
+use nu_stream::trace_stream;
+
+pub(crate) async fn run_external_command(
+    command: ExternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+) -> Result<InputStream, ShellError> {
+    trace!(target: "nu::run::external", "-> {}", command.name);
+
+    if !did_find_command(&command.name) {
+        return Err(ShellError::labeled_error(
+            "Command not found",
+            "command not found",
+            &command.name_tag,
+        ));
+    }
+
+    run_with_stdin(command, context, input, external_redirection).await
+}
+
+async fn run_with_stdin(
+    command: ExternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+) -> Result<InputStream, ShellError> {
+    let path = context.shell_manager.path();
+
+    let input = trace_stream!(target: "nu::trace_stream::external::stdin", "input" = input);
+
+    let mut command_args = vec![];
+    for arg in command.args.iter() {
+        let is_literal = matches!(arg.expr, Expression::Literal(_));
+        let value = evaluate_baseline_expr(arg, context).await?;
+
+        // Skip any arguments that don't really exist, treating them as optional
+        // FIXME: we may want to preserve the gap in the future, though it's hard to say
+        // what value we would put in its place.
+        if value.value.is_none() {
+            continue;
+        }
+
+        // Do the cleanup that we need to do on any argument going out:
+        match &value.value {
+            UntaggedValue::Table(table) => {
+                for t in table {
+                    match &t.value {
+                        UntaggedValue::Primitive(_) => {
+                            command_args.push((
+                                t.convert_to_string().trim_end_matches('\n').to_string(),
+                                is_literal,
+                            ));
+                        }
+                        _ => {
+                            return Err(ShellError::labeled_error(
+                                "Could not convert to positional arguments",
+                                "could not convert to positional arguments",
+                                value.tag(),
+                            ));
+                        }
+                    }
+                }
+            }
+            _ => {
+                let trimmed_value_string = value.as_string()?.trim_end_matches('\n').to_string();
+                command_args.push((trimmed_value_string, is_literal));
+            }
+        }
+    }
+
+    let process_args = command_args
+        .iter()
+        .map(|(arg, _is_literal)| {
+            let home_dir;
+
+            #[cfg(feature = "dirs")]
+            {
+                home_dir = dirs::home_dir;
+            }
+            #[cfg(not(feature = "dirs"))]
+            {
+                home_dir = || Some(std::path::PathBuf::from("/"));
+            }
+
+            let arg = expand_tilde(arg.deref(), home_dir);
+
+            #[cfg(not(windows))]
+            {
+                if !_is_literal {
+                    let escaped = escape_double_quotes(&arg);
+                    add_double_quotes(&escaped)
+                } else {
+                    arg.as_ref().to_string()
+                }
+            }
+            #[cfg(windows)]
+            {
+                if let Some(unquoted) = remove_quotes(&arg) {
+                    unquoted.to_string()
+                } else {
+                    arg.as_ref().to_string()
+                }
+            }
+        })
+        .collect::<Vec<String>>();
+
+    spawn(
+        &command,
+        &path,
+        &process_args[..],
+        input,
+        external_redirection,
+        &context.scope,
+    )
+}
+
+fn spawn(
+    command: &ExternalCommand,
+    path: &str,
+    args: &[String],
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+    scope: &Scope,
+) -> Result<InputStream, ShellError> {
+    let command = command.clone();
+
+    let mut process = {
+        #[cfg(windows)]
+        {
+            let mut process = Command::new("cmd");
+            process.arg("/c");
+            process.arg(&command.name);
+            for arg in args {
+                // Clean the args before we use them:
+                let arg = arg.replace("|", "\\|");
+                process.arg(&arg);
+            }
+            process
+        }
+
+        #[cfg(not(windows))]
+        {
+            let cmd_with_args = vec![command.name.clone(), args.join(" ")].join(" ");
+            let mut process = Command::new("sh");
+            process.arg("-c").arg(cmd_with_args);
+            process
+        }
+    };
+
+    process.current_dir(path);
+    trace!(target: "nu::run::external", "cwd = {:?}", &path);
+
+    process.env_clear();
+    process.envs(scope.get_env_vars());
+
+    // We want stdout regardless of what
+    // we are doing ($it case or pipe stdin)
+    match external_redirection {
+        ExternalRedirection::Stdout => {
+            process.stdout(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stdout pipe");
+        }
+        ExternalRedirection::Stderr => {
+            process.stderr(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stderr pipe");
+        }
+        ExternalRedirection::StdoutAndStderr => {
+            process.stdout(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stdout pipe");
+            process.stderr(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stderr pipe");
+        }
+        _ => {}
+    }
+
+    // open since we have some contents for stdin
+    if !input.is_empty() {
+        process.stdin(Stdio::piped());
+        trace!(target: "nu::run::external", "set up stdin pipe");
+    }
+
+    trace!(target: "nu::run::external", "built command {:?}", process);
+
+    // TODO Switch to async_std::process once it's stabilized
+    if let Ok(mut child) = process.spawn() {
+        let (tx, rx) = mpsc::sync_channel(0);
+
+        let mut stdin = child.stdin.take();
+
+        let stdin_write_tx = tx.clone();
+        let stdout_read_tx = tx;
+        let stdin_name_tag = command.name_tag.clone();
+        let stdout_name_tag = command.name_tag;
+
+        std::thread::spawn(move || {
+            if !input.is_empty() {
+                let mut stdin_write = stdin
+                    .take()
+                    .expect("Internal error: could not get stdin pipe for external command");
+
+                for value in block_on_stream(input) {
+                    match &value.value {
+                        UntaggedValue::Primitive(Primitive::Nothing) => continue,
+                        UntaggedValue::Primitive(Primitive::String(s)) => {
+                            if stdin_write.write(s.as_bytes()).is_err() {
+                                // Other side has closed, so exit
+                                return Ok(());
+                            }
+                        }
+                        UntaggedValue::Primitive(Primitive::Binary(b)) => {
+                            if stdin_write.write(b).is_err() {
+                                // Other side has closed, so exit
+                                return Ok(());
+                            }
+                        }
+                        unsupported => {
+                            println!("Unsupported: {:?}", unsupported);
+                            let _ = stdin_write_tx.send(Ok(Value {
+                                value: UntaggedValue::Error(ShellError::labeled_error(
+                                    format!(
+                                        "Received unexpected type from pipeline ({})",
+                                        unsupported.type_name()
+                                    ),
+                                    "expected a string",
+                                    stdin_name_tag.clone(),
+                                )),
+                                tag: stdin_name_tag,
+                            }));
+                            return Err(());
+                        }
+                    };
+                }
+            }
+
+            Ok(())
+        });
+
+        std::thread::spawn(move || {
+            if external_redirection == ExternalRedirection::Stdout
+                || external_redirection == ExternalRedirection::StdoutAndStderr
+            {
+                let stdout = if let Some(stdout) = child.stdout.take() {
+                    stdout
+                } else {
+                    let _ = stdout_read_tx.send(Ok(Value {
+                        value: UntaggedValue::Error(ShellError::labeled_error(
+                            "Can't redirect the stdout for external command",
+                            "can't redirect stdout",
+                            &stdout_name_tag,
+                        )),
+                        tag: stdout_name_tag,
+                    }));
+                    return Err(());
+                };
+
+                let file = futures::io::AllowStdIo::new(stdout);
+                let stream = FramedRead::new(file, MaybeTextCodec::default());
+
+                for line in block_on_stream(stream) {
+                    match line {
+                        Ok(line) => match line {
+                            StringOrBinary::String(s) => {
+                                let result = stdout_read_tx.send(Ok(Value {
+                                    value: UntaggedValue::Primitive(Primitive::String(s.clone())),
+                                    tag: stdout_name_tag.clone(),
+                                }));
+
+                                if result.is_err() {
+                                    break;
+                                }
+                            }
+                            StringOrBinary::Binary(b) => {
+                                let result = stdout_read_tx.send(Ok(Value {
+                                    value: UntaggedValue::Primitive(Primitive::Binary(
+                                        b.into_iter().collect(),
+                                    )),
+                                    tag: stdout_name_tag.clone(),
+                                }));
+
+                                if result.is_err() {
+                                    break;
+                                }
+                            }
+                        },
+                        Err(e) => {
+                            // If there's an exit status, it makes sense that we may error when
+                            // trying to read from its stdout pipe (likely been closed). In that
+                            // case, don't emit an error.
+                            let should_error = match child.wait() {
+                                Ok(exit_status) => !exit_status.success(),
+                                Err(_) => true,
+                            };
+
+                            if should_error {
+                                let _ = stdout_read_tx.send(Ok(Value {
+                                    value: UntaggedValue::Error(ShellError::labeled_error(
+                                        format!("Unable to read from stdout ({})", e),
+                                        "unable to read from stdout",
+                                        &stdout_name_tag,
+                                    )),
+                                    tag: stdout_name_tag.clone(),
+                                }));
+                            }
+
+                            return Ok(());
+                        }
+                    }
+                }
+            }
+            if external_redirection == ExternalRedirection::Stderr
+                || external_redirection == ExternalRedirection::StdoutAndStderr
+            {
+                let stderr = if let Some(stderr) = child.stderr.take() {
+                    stderr
+                } else {
+                    let _ = stdout_read_tx.send(Ok(Value {
+                        value: UntaggedValue::Error(ShellError::labeled_error(
+                            "Can't redirect the stderr for external command",
+                            "can't redirect stderr",
+                            &stdout_name_tag,
+                        )),
+                        tag: stdout_name_tag,
+                    }));
+                    return Err(());
+                };
+
+                let file = futures::io::AllowStdIo::new(stderr);
+                let stream = FramedRead::new(file, MaybeTextCodec::default());
+
+                for line in block_on_stream(stream) {
+                    match line {
+                        Ok(line) => match line {
+                            StringOrBinary::String(s) => {
+                                let result = stdout_read_tx.send(Ok(Value {
+                                    value: UntaggedValue::Error(
+                                        ShellError::untagged_runtime_error(s),
+                                    ),
+                                    tag: stdout_name_tag.clone(),
+                                }));
+
+                                if result.is_err() {
+                                    break;
+                                }
+                            }
+                            StringOrBinary::Binary(_) => {
+                                let result = stdout_read_tx.send(Ok(Value {
+                                    value: UntaggedValue::Error(
+                                        ShellError::untagged_runtime_error("<binary stderr>"),
+                                    ),
+                                    tag: stdout_name_tag.clone(),
+                                }));
+
+                                if result.is_err() {
+                                    break;
+                                }
+                            }
+                        },
+                        Err(e) => {
+                            // If there's an exit status, it makes sense that we may error when
+                            // trying to read from its stdout pipe (likely been closed). In that
+                            // case, don't emit an error.
+                            let should_error = match child.wait() {
+                                Ok(exit_status) => !exit_status.success(),
+                                Err(_) => true,
+                            };
+
+                            if should_error {
+                                let _ = stdout_read_tx.send(Ok(Value {
+                                    value: UntaggedValue::Error(ShellError::labeled_error(
+                                        format!("Unable to read from stdout ({})", e),
+                                        "unable to read from stdout",
+                                        &stdout_name_tag,
+                                    )),
+                                    tag: stdout_name_tag.clone(),
+                                }));
+                            }
+
+                            return Ok(());
+                        }
+                    }
+                }
+            }
+
+            // We can give an error when we see a non-zero exit code, but this is different
+            // than what other shells will do.
+            let external_failed = match child.wait() {
+                Err(_) => true,
+                Ok(exit_status) => !exit_status.success(),
+            };
+
+            if external_failed {
+                let cfg = nu_data::config::config(Tag::unknown());
+                if let Ok(cfg) = cfg {
+                    if cfg.contains_key("nonzero_exit_errors") {
+                        let _ = stdout_read_tx.send(Ok(Value {
+                            value: UntaggedValue::Error(ShellError::labeled_error(
+                                "External command failed",
+                                "command failed",
+                                &stdout_name_tag,
+                            )),
+                            tag: stdout_name_tag.clone(),
+                        }));
+                    }
+                }
+                let _ = stdout_read_tx.send(Ok(Value {
+                    value: UntaggedValue::Error(ShellError::external_non_zero()),
+                    tag: stdout_name_tag,
+                }));
+            }
+
+            Ok(())
+        });
+
+        let stream = ThreadedReceiver::new(rx);
+        Ok(stream.to_input_stream())
+    } else {
+        Err(ShellError::labeled_error(
+            "Failed to spawn process",
+            "failed to spawn",
+            &command.name_tag,
+        ))
+    }
+}
+
+pub fn did_find_command(#[allow(unused)] name: &str) -> bool {
+    #[cfg(not(feature = "which"))]
+    {
+        // we can't perform this check, so just assume it can be found
+        true
+    }
+
+    #[cfg(all(feature = "which", unix))]
+    {
+        which::which(name).is_ok()
+    }
+
+    #[cfg(all(feature = "which", windows))]
+    {
+        if which::which(name).is_ok() {
+            true
+        } else {
+            // Reference: https://ss64.com/nt/syntax-internal.html
+            let cmd_builtins = [
+                "assoc", "break", "color", "copy", "date", "del", "dir", "dpath", "echo", "erase",
+                "for", "ftype", "md", "mkdir", "mklink", "move", "path", "ren", "rename", "rd",
+                "rmdir", "set", "start", "time", "title", "type", "ver", "verify", "vol",
+            ];
+
+            cmd_builtins.contains(&name)
+        }
+    }
+}
+
+fn expand_tilde<SI: ?Sized, P, HD>(input: &SI, home_dir: HD) -> std::borrow::Cow<str>
+where
+    SI: AsRef<str>,
+    P: AsRef<std::path::Path>,
+    HD: FnOnce() -> Option<P>,
+{
+    shellexpand::tilde_with_context(input, home_dir)
+}
+
+fn argument_is_quoted(argument: &str) -> bool {
+    if argument.len() < 2 {
+        return false;
+    }
+
+    (argument.starts_with('"') && argument.ends_with('"'))
+        || (argument.starts_with('\'') && argument.ends_with('\''))
+}
+
+#[allow(unused)]
+fn add_double_quotes(argument: &str) -> String {
+    format!("\"{}\"", argument)
+}
+
+#[allow(unused)]
+fn escape_double_quotes(argument: &str) -> Cow<'_, str> {
+    // allocate new string only if required
+    if argument.contains('"') {
+        Cow::Owned(argument.replace('"', r#"\""#))
+    } else {
+        Cow::Borrowed(argument)
+    }
+}
+
+#[allow(unused)]
+fn remove_quotes(argument: &str) -> Option<&str> {
+    if !argument_is_quoted(argument) {
+        return None;
+    }
+
+    let size = argument.len();
+
+    Some(&argument[1..size - 1])
+}
+
+#[allow(unused)]
+fn shell_os_paths() -> Vec<std::path::PathBuf> {
+    let mut original_paths = vec![];
+
+    if let Some(paths) = std::env::var_os("PATH") {
+        original_paths = std::env::split_paths(&paths).collect::<Vec<_>>();
+    }
+
+    original_paths
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        add_double_quotes, argument_is_quoted, escape_double_quotes, expand_tilde, remove_quotes,
+    };
+    #[cfg(feature = "which")]
+    use super::{run_external_command, InputStream};
+
+    #[cfg(feature = "which")]
+    use futures::executor::block_on;
+    #[cfg(feature = "which")]
+    use nu_engine::basic_evaluation_context;
+    #[cfg(feature = "which")]
+    use nu_errors::ShellError;
+    #[cfg(feature = "which")]
+    use nu_test_support::commands::ExternalBuilder;
+    // async fn read(mut stream: OutputStream) -> Option<Value> {
+    //     match stream.try_next().await {
+    //         Ok(val) => {
+    //             if let Some(val) = val {
+    //                 val.raw_value()
+    //             } else {
+    //                 None
+    //             }
+    //         }
+    //         Err(_) => None,
+    //     }
+    // }
+
+    #[cfg(feature = "which")]
+    async fn non_existent_run() -> Result<(), ShellError> {
+        use nu_protocol::hir::ExternalRedirection;
+        let cmd = ExternalBuilder::for_name("i_dont_exist.exe").build();
+
+        let input = InputStream::empty();
+        let mut ctx =
+            basic_evaluation_context().expect("There was a problem creating a basic context.");
+
+        assert!(
+            run_external_command(cmd, &mut ctx, input, ExternalRedirection::Stdout)
+                .await
+                .is_err()
+        );
+
+        Ok(())
+    }
+
+    // async fn failure_run() -> Result<(), ShellError> {
+    //     let cmd = ExternalBuilder::for_name("fail").build();
+
+    //     let mut ctx = crate::cli::basic_evaluation_context().expect("There was a problem creating a basic context.");
+    //     let stream = run_external_command(cmd, &mut ctx, None, false)
+    //         .await?
+    //         .expect("There was a problem running the external command.");
+
+    //     match read(stream.into()).await {
+    //         Some(Value {
+    //             value: UntaggedValue::Error(_),
+    //             ..
+    //         }) => {}
+    //         None | _ => panic!("Command didn't fail."),
+    //     }
+
+    //     Ok(())
+    // }
+
+    // #[test]
+    // fn identifies_command_failed() -> Result<(), ShellError> {
+    //     block_on(failure_run())
+    // }
+
+    #[cfg(feature = "which")]
+    #[test]
+    fn identifies_command_not_found() -> Result<(), ShellError> {
+        block_on(non_existent_run())
+    }
+
+    #[test]
+    fn checks_escape_double_quotes() {
+        assert_eq!(escape_double_quotes("andrés"), "andrés");
+        assert_eq!(escape_double_quotes(r#"an"drés"#), r#"an\"drés"#);
+        assert_eq!(escape_double_quotes(r#""an"drés""#), r#"\"an\"drés\""#);
+    }
+
+    #[test]
+    fn checks_quotes_from_argument_to_be_passed_in() {
+        assert_eq!(argument_is_quoted(""), false);
+
+        assert_eq!(argument_is_quoted("'"), false);
+        assert_eq!(argument_is_quoted("'a"), false);
+        assert_eq!(argument_is_quoted("a"), false);
+        assert_eq!(argument_is_quoted("a'"), false);
+        assert_eq!(argument_is_quoted("''"), true);
+
+        assert_eq!(argument_is_quoted(r#"""#), false);
+        assert_eq!(argument_is_quoted(r#""a"#), false);
+        assert_eq!(argument_is_quoted(r#"a"#), false);
+        assert_eq!(argument_is_quoted(r#"a""#), false);
+        assert_eq!(argument_is_quoted(r#""""#), true);
+
+        assert_eq!(argument_is_quoted("'andrés"), false);
+        assert_eq!(argument_is_quoted("andrés'"), false);
+        assert_eq!(argument_is_quoted(r#""andrés"#), false);
+        assert_eq!(argument_is_quoted(r#"andrés""#), false);
+        assert_eq!(argument_is_quoted("'andrés'"), true);
+        assert_eq!(argument_is_quoted(r#""andrés""#), true);
+    }
+
+    #[test]
+    fn adds_double_quotes_to_argument_to_be_passed_in() {
+        assert_eq!(add_double_quotes("andrés"), "\"andrés\"");
+    }
+
+    #[test]
+    fn strips_quotes_from_argument_to_be_passed_in() {
+        assert_eq!(remove_quotes(""), None);
+
+        assert_eq!(remove_quotes("'"), None);
+        assert_eq!(remove_quotes("'a"), None);
+        assert_eq!(remove_quotes("a"), None);
+        assert_eq!(remove_quotes("a'"), None);
+        assert_eq!(remove_quotes("''"), Some(""));
+
+        assert_eq!(remove_quotes(r#"""#), None);
+        assert_eq!(remove_quotes(r#""a"#), None);
+        assert_eq!(remove_quotes(r#"a"#), None);
+        assert_eq!(remove_quotes(r#"a""#), None);
+        assert_eq!(remove_quotes(r#""""#), Some(""));
+
+        assert_eq!(remove_quotes("'andrés"), None);
+        assert_eq!(remove_quotes("andrés'"), None);
+        assert_eq!(remove_quotes(r#""andrés"#), None);
+        assert_eq!(remove_quotes(r#"andrés""#), None);
+        assert_eq!(remove_quotes("'andrés'"), Some("andrés"));
+        assert_eq!(remove_quotes(r#""andrés""#), Some("andrés"));
+    }
+
+    #[test]
+    fn expands_tilde_if_starts_with_tilde_character() {
+        assert_eq!(
+            expand_tilde("~", || Some(std::path::Path::new("the_path_to_nu_light"))),
+            "the_path_to_nu_light"
+        );
+    }
+
+    #[test]
+    fn does_not_expand_tilde_if_tilde_is_not_first_character() {
+        assert_eq!(
+            expand_tilde("1~1", || Some(std::path::Path::new("the_path_to_nu_light"))),
+            "1~1"
+        );
+    }
+}

crates/nu-command/src/commands/classified/mod.rs

@@ -0,0 +1,5 @@
+mod dynamic;
+pub(crate) mod external;
+
+#[allow(unused_imports)]
+pub(crate) use dynamic::Command as DynamicCommand;

crates/nu-command/src/commands/clear.rs

@@ -0,0 +1,45 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::Signature;
+use std::process::Command;
+
+pub struct Clear;
+
+#[async_trait]
+impl WholeStreamCommand for Clear {
+    fn name(&self) -> &str {
+        "clear"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("clear")
+    }
+
+    fn usage(&self) -> &str {
+        "Clears the terminal"
+    }
+
+    async fn run(&self, _: CommandArgs) -> Result<OutputStream, ShellError> {
+        if cfg!(windows) {
+            Command::new("cmd")
+                .args(&["/C", "cls"])
+                .status()
+                .expect("failed to execute process");
+        } else if cfg!(unix) {
+            Command::new("/bin/sh")
+                .args(&["-c", "clear"])
+                .status()
+                .expect("failed to execute process");
+        }
+        Ok(OutputStream::empty())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Clear the screen",
+            example: "clear",
+            result: None,
+        }]
+    }
+}

crates/nu-command/src/commands/clip.rs

@@ -0,0 +1,106 @@
+use crate::prelude::*;
+use futures::stream::StreamExt;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, Value};
+
+use arboard::Clipboard;
+
+pub struct Clip;
+
+#[async_trait]
+impl WholeStreamCommand for Clip {
+    fn name(&self) -> &str {
+        "clip"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("clip")
+    }
+
+    fn usage(&self) -> &str {
+        "Copy the contents of the pipeline to the copy/paste buffer"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        clip(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Save text to the clipboard",
+                example: "echo 'secret value' | clip",
+                result: None,
+            },
+            Example {
+                description: "Save numbers to the clipboard",
+                example: "random integer 10000000..99999999 | clip",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn clip(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let input = args.input;
+    let name = args.call_info.name_tag.clone();
+    let values: Vec<Value> = input.collect().await;
+
+    if let Ok(mut clip_context) = Clipboard::new() {
+        let mut new_copy_data = String::new();
+
+        if !values.is_empty() {
+            let mut first = true;
+            for i in values.iter() {
+                if !first {
+                    new_copy_data.push('\n');
+                } else {
+                    first = false;
+                }
+
+                let string: String = i.convert_to_string();
+                if string.is_empty() {
+                    return Err(ShellError::labeled_error(
+                        "Unable to convert to string",
+                        "Unable to convert to string",
+                        name,
+                    ));
+                }
+
+                new_copy_data.push_str(&string);
+            }
+        }
+
+        match clip_context.set_text(new_copy_data) {
+            Ok(_) => {}
+            Err(_) => {
+                return Err(ShellError::labeled_error(
+                    "Could not set contents of clipboard",
+                    "could not set contents of clipboard",
+                    name,
+                ));
+            }
+        }
+    } else {
+        return Err(ShellError::labeled_error(
+            "Could not open clipboard",
+            "could not open clipboard",
+            name,
+        ));
+    }
+    Ok(OutputStream::empty())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Clip;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Clip {})?)
+    }
+}

crates/nu-command/src/commands/command.rs

@@ -0,0 +1,21 @@
+use crate::prelude::*;
+use nu_engine::Command;
+use nu_errors::ShellError;
+use parking_lot::Mutex;
+use std::sync::atomic::AtomicBool;
+
+pub struct RunnableContext {
+    pub input: InputStream,
+    pub shell_manager: ShellManager,
+    pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
+    pub ctrl_c: Arc<AtomicBool>,
+    pub current_errors: Arc<Mutex<Vec<ShellError>>>,
+    pub scope: Scope,
+    pub name: Tag,
+}
+
+impl RunnableContext {
+    pub fn get_command(&self, name: &str) -> Option<Command> {
+        self.scope.get_command(name)
+    }
+}

crates/nu-command/src/commands/compact.rs

@@ -0,0 +1,86 @@
+use crate::prelude::*;
+use futures::future;
+use futures::stream::StreamExt;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct Compact;
+
+#[derive(Deserialize)]
+pub struct CompactArgs {
+    rest: Vec<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Compact {
+    fn name(&self) -> &str {
+        "compact"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("compact").rest(SyntaxShape::Any, "the columns to compact from the table")
+    }
+
+    fn usage(&self) -> &str {
+        "Creates a table with non-empty rows"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        compact(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Filter out all directory entries having no 'target'",
+            example: "ls -la | compact target",
+            result: None,
+        }]
+    }
+}
+
+pub async fn compact(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (CompactArgs { rest: columns }, input) = args.process().await?;
+    Ok(input
+        .filter_map(move |item| {
+            future::ready(if columns.is_empty() {
+                if !item.is_empty() {
+                    Some(ReturnSuccess::value(item))
+                } else {
+                    None
+                }
+            } else {
+                match item {
+                    Value {
+                        value: UntaggedValue::Row(ref r),
+                        ..
+                    } => {
+                        if columns
+                            .iter()
+                            .all(|field| r.get_data(field).borrow().is_some())
+                        {
+                            Some(ReturnSuccess::value(item))
+                        } else {
+                            None
+                        }
+                    }
+                    _ => None,
+                }
+            })
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Compact;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Compact {})?)
+    }
+}

crates/nu-command/src/commands/config/clear.rs

@@ -0,0 +1,49 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct SubCommand;
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config clear"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config clear")
+    }
+
+    fn usage(&self) -> &str {
+        "clear the config"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        clear(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Clear the config (be careful!)",
+            example: "config clear",
+            result: None,
+        }]
+    }
+}
+
+pub async fn clear(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_span = args.call_info.name_tag.clone();
+
+    // NOTE: None because we are not loading a new config file, we just want to read from the
+    // existing config
+    let mut result = nu_data::config::read(name_span, &None)?;
+
+    result.clear();
+
+    config::write(&result, &None)?;
+
+    Ok(OutputStream::one(ReturnSuccess::value(
+        UntaggedValue::Row(result.into()).into_value(args.call_info.name_tag),
+    )))
+}

crates/nu-command/src/commands/config/command.rs

@@ -0,0 +1,34 @@
+use crate::prelude::*;
+use nu_engine::CommandArgs;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+use nu_stream::OutputStream;
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "config"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config")
+    }
+
+    fn usage(&self) -> &str {
+        "Configuration management."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let name_span = args.call_info.name_tag.clone();
+        let name = args.call_info.name_tag;
+        let result = nu_data::config::read(name_span, &None)?;
+
+        Ok(futures::stream::iter(vec![ReturnSuccess::value(
+            UntaggedValue::Row(result.into()).into_value(name),
+        )])
+        .to_output_stream())
+    }
+}

crates/nu-command/src/commands/config/get.rs

@@ -0,0 +1,68 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+pub struct GetArgs {
+    path: ColumnPath,
+}
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config get"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config get").required(
+            "get",
+            SyntaxShape::ColumnPath,
+            "value to get from the config",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Gets a value from the config"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        get(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the current startup commands",
+            example: "config get startup",
+            result: None,
+        }]
+    }
+}
+
+pub async fn get(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_tag = args.call_info.name_tag.clone();
+    let (GetArgs { path }, _) = args.process().await?;
+
+    // NOTE: None because we are not loading a new config file, we just want to read from the
+    // existing config
+    let result = UntaggedValue::row(nu_data::config::read(&name_tag, &None)?).into_value(&name_tag);
+
+    let value = crate::commands::get::get_column_path(&path, &result)?;
+
+    Ok(match value {
+        Value {
+            value: UntaggedValue::Table(list),
+            ..
+        } => {
+            let list: Vec<_> = list
+                .iter()
+                .map(|x| ReturnSuccess::value(x.clone()))
+                .collect();
+
+            futures::stream::iter(list).to_output_stream()
+        }
+        x => OutputStream::one(ReturnSuccess::value(x)),
+    })
+}

crates/nu-command/src/commands/config/load.rs

@@ -0,0 +1,51 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+use std::path::PathBuf;
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+pub struct LoadArgs {
+    load: Tagged<PathBuf>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config load"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config load").required(
+            "load",
+            SyntaxShape::FilePath,
+            "Path to load the config from",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Loads the config from the path given"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set(args).await
+    }
+}
+
+pub async fn set(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let name_span = args.call_info.name_tag.clone();
+    let (LoadArgs { load }, _) = args.process().await?;
+
+    let configuration = load.item().clone();
+
+    let result = nu_data::config::read(name_span, &Some(configuration))?;
+
+    Ok(futures::stream::iter(vec![ReturnSuccess::value(
+        UntaggedValue::Row(result.into()).into_value(name),
+    )])
+    .to_output_stream())
+}

crates/nu-command/src/commands/config/mod.rs

@@ -0,0 +1,17 @@
+pub mod clear;
+pub mod command;
+pub mod get;
+pub mod load;
+pub mod path;
+pub mod remove;
+pub mod set;
+pub mod set_into;
+
+pub use clear::SubCommand as ConfigClear;
+pub use command::Command as Config;
+pub use get::SubCommand as ConfigGet;
+pub use load::SubCommand as ConfigLoad;
+pub use path::SubCommand as ConfigPath;
+pub use remove::SubCommand as ConfigRemove;
+pub use set::SubCommand as ConfigSet;
+pub use set_into::SubCommand as ConfigSetInto;

crates/nu-command/src/commands/config/path.rs

@@ -0,0 +1,41 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue};
+
+pub struct SubCommand;
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config path"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config path")
+    }
+
+    fn usage(&self) -> &str {
+        "return the path to the config file"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        path(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the path to the current config file",
+            example: "config path",
+            result: None,
+        }]
+    }
+}
+
+pub async fn path(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let path = config::default_path()?;
+
+    Ok(OutputStream::one(ReturnSuccess::value(
+        UntaggedValue::Primitive(Primitive::FilePath(path)).into_value(args.call_info.name_tag),
+    )))
+}

crates/nu-command/src/commands/config/remove.rs

@@ -0,0 +1,67 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+pub struct RemoveArgs {
+    remove: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config remove"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config remove").required(
+            "remove",
+            SyntaxShape::Any,
+            "remove a value from the config",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Removes a value from the config"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        remove(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Remove the startup commands",
+            example: "config remove startup",
+            result: None,
+        }]
+    }
+}
+
+pub async fn remove(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_span = args.call_info.name_tag.clone();
+    let (RemoveArgs { remove }, _) = args.process().await?;
+
+    let mut result = nu_data::config::read(name_span, &None)?;
+
+    let key = remove.to_string();
+
+    if result.contains_key(&key) {
+        result.swap_remove(&key);
+        config::write(&result, &None)?;
+        Ok(futures::stream::iter(vec![ReturnSuccess::value(
+            UntaggedValue::Row(result.into()).into_value(remove.tag()),
+        )])
+        .to_output_stream())
+    } else {
+        Err(ShellError::labeled_error(
+            "Key does not exist in config",
+            "key",
+            remove.tag(),
+        ))
+    }
+}

crates/nu-command/src/commands/config/set.rs

@@ -0,0 +1,89 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+pub struct SetArgs {
+    path: ColumnPath,
+    value: Value,
+}
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config set"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config set")
+            .required("key", SyntaxShape::ColumnPath, "variable name to set")
+            .required("value", SyntaxShape::Any, "value to use")
+    }
+
+    fn usage(&self) -> &str {
+        "Sets a value in the config"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Set auto pivoting",
+                example: "config set pivot_mode always",
+                result: None,
+            },
+            Example {
+                description: "Set line editor options",
+                example: "config set line_editor [[edit_mode, completion_type]; [emacs circular]]",
+                result: None,
+            },
+            Example {
+                description: "Set coloring options",
+                example: "config set color_config [[header_align header_bold]; [left $true]]",
+                result: None,
+            },
+            Example {
+                description: "Set nested options",
+                example: "config set color_config.header_color white",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn set(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_tag = args.call_info.name_tag.clone();
+    let (SetArgs { path, mut value }, _) = args.process().await?;
+
+    // NOTE: None because we are not loading a new config file, we just want to read from the
+    // existing config
+    let raw_entries = nu_data::config::read(&name_tag, &None)?;
+    let configuration = UntaggedValue::row(raw_entries).into_value(&name_tag);
+
+    if let UntaggedValue::Table(rows) = &value.value {
+        if rows.len() == 1 && rows[0].is_row() {
+            value = rows[0].clone();
+        }
+    }
+
+    match configuration.forgiving_insert_data_at_column_path(&path, value) {
+        Ok(Value {
+            value: UntaggedValue::Row(changes),
+            ..
+        }) => {
+            config::write(&changes.entries, &None)?;
+
+            Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::Row(changes).into_value(name_tag),
+            )))
+        }
+        Ok(_) => Ok(OutputStream::empty()),
+        Err(reason) => Err(reason),
+    }
+}

crates/nu-command/src/commands/config/set_into.rs

@@ -0,0 +1,90 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct SubCommand;
+
+#[derive(Deserialize)]
+pub struct SetIntoArgs {
+    set_into: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "config set_into"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("config set_into").required(
+            "set_into",
+            SyntaxShape::String,
+            "sets a variable from values in the pipeline",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Sets a value in the config"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set_into(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Store the contents of the pipeline as a path",
+            example: "echo ['/usr/bin' '/bin'] | config set_into path",
+            result: None,
+        }]
+    }
+}
+
+pub async fn set_into(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_span = args.call_info.name_tag.clone();
+    let name = args.call_info.name_tag.clone();
+
+    let (SetIntoArgs { set_into: v }, input) = args.process().await?;
+
+    // NOTE: None because we are not loading a new config file, we just want to read from the
+    // existing config
+    let mut result = nu_data::config::read(name_span, &None)?;
+
+    // In the original code, this is set to `Some` if the `load flag is set`
+    let configuration = None;
+
+    let rows: Vec<Value> = input.collect().await;
+    let key = v.to_string();
+
+    Ok(if rows.is_empty() {
+        return Err(ShellError::labeled_error(
+            "No values given for set_into",
+            "needs value(s) from pipeline",
+            v.tag(),
+        ));
+    } else if rows.len() == 1 {
+        // A single value
+        let value = &rows[0];
+
+        result.insert(key, value.clone());
+
+        config::write(&result, &configuration)?;
+
+        OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::Row(result.into()).into_value(name),
+        ))
+    } else {
+        // Take in the pipeline as a table
+        let value = UntaggedValue::Table(rows).into_value(name.clone());
+
+        result.insert(key, value);
+
+        config::write(&result, &configuration)?;
+
+        OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::Row(result.into()).into_value(name),
+        ))
+    })
+}

crates/nu-command/src/commands/constants.rs

@@ -0,0 +1,358 @@
+pub const BAT_LANGUAGES: &[&str] = &[
+    "as",
+    "csv",
+    "tsv",
+    "applescript",
+    "script editor",
+    "s",
+    "S",
+    "adoc",
+    "asciidoc",
+    "asc",
+    "asa",
+    "yasm",
+    "nasm",
+    "asm",
+    "inc",
+    "mac",
+    "awk",
+    "bat",
+    "cmd",
+    "bib",
+    "sh",
+    "bash",
+    "zsh",
+    ".bash_aliases",
+    ".bash_completions",
+    ".bash_functions",
+    ".bash_login",
+    ".bash_logout",
+    ".bash_profile",
+    ".bash_variables",
+    ".bashrc",
+    ".profile",
+    ".textmate_init",
+    ".zshrc",
+    "PKGBUILD",
+    ".ebuild",
+    ".eclass",
+    "c",
+    "h",
+    "cs",
+    "csx",
+    "cpp",
+    "cc",
+    "cp",
+    "cxx",
+    "c++",
+    "C",
+    "h",
+    "hh",
+    "hpp",
+    "hxx",
+    "h++",
+    "inl",
+    "ipp",
+    "cabal",
+    "clj",
+    "cljc",
+    "cljs",
+    "edn",
+    "CMakeLists.txt",
+    "cmake",
+    "h.in",
+    "hh.in",
+    "hpp.in",
+    "hxx.in",
+    "h++.in",
+    "CMakeCache.txt",
+    "cr",
+    "css",
+    "css.erb",
+    "css.liquid",
+    "d",
+    "di",
+    "dart",
+    "diff",
+    "patch",
+    "Dockerfile",
+    "dockerfile",
+    "ex",
+    "exs",
+    "elm",
+    "erl",
+    "hrl",
+    "Emakefile",
+    "emakefile",
+    "fs",
+    "fsi",
+    "fsx",
+    "fs",
+    "fsi",
+    "fsx",
+    "fish",
+    "attributes",
+    "gitattributes",
+    ".gitattributes",
+    "COMMIT_EDITMSG",
+    "MERGE_MSG",
+    "TAG_EDITMSG",
+    "gitconfig",
+    ".gitconfig",
+    ".gitmodules",
+    "exclude",
+    "gitignore",
+    ".gitignore",
+    ".git",
+    "gitlog",
+    "git-rebase-todo",
+    "go",
+    "dot",
+    "DOT",
+    "gv",
+    "groovy",
+    "gvy",
+    "gradle",
+    "Jenkinsfile",
+    "hs",
+    "hs",
+    "hsc",
+    "show-nonprintable",
+    "html",
+    "htm",
+    "shtml",
+    "xhtml",
+    "asp",
+    "html.eex",
+    "yaws",
+    "rails",
+    "rhtml",
+    "erb",
+    "html.erb",
+    "adp",
+    "twig",
+    "html.twig",
+    "ini",
+    "INI",
+    "INF",
+    "reg",
+    "REG",
+    "lng",
+    "cfg",
+    "CFG",
+    "desktop",
+    "url",
+    "URL",
+    ".editorconfig",
+    ".hgrc",
+    "hgrc",
+    "java",
+    "bsh",
+    "properties",
+    "jsp",
+    "js",
+    "htc",
+    "js",
+    "jsx",
+    "babel",
+    "es6",
+    "js.erb",
+    "json",
+    "sublime-settings",
+    "sublime-menu",
+    "sublime-keymap",
+    "sublime-mousemap",
+    "sublime-theme",
+    "sublime-build",
+    "sublime-project",
+    "sublime-completions",
+    "sublime-commands",
+    "sublime-macro",
+    "sublime-color-scheme",
+    "ipynb",
+    "Pipfile.lock",
+    "jsonnet",
+    "libsonnet",
+    "libjsonnet",
+    "jl",
+    "kt",
+    "kts",
+    "tex",
+    "ltx",
+    "less",
+    "css.less",
+    "lisp",
+    "cl",
+    "clisp",
+    "l",
+    "mud",
+    "el",
+    "scm",
+    "ss",
+    "lsp",
+    "fasl",
+    "lhs",
+    "lua",
+    "make",
+    "GNUmakefile",
+    "makefile",
+    "Makefile",
+    "makefile.am",
+    "Makefile.am",
+    "makefile.in",
+    "Makefile.in",
+    "OCamlMakefile",
+    "mak",
+    "mk",
+    "md",
+    "mdown",
+    "markdown",
+    "markdn",
+    "matlab",
+    "build",
+    "nix",
+    "m",
+    "h",
+    "mm",
+    "M",
+    "h",
+    "ml",
+    "mli",
+    "mll",
+    "mly",
+    "pas",
+    "p",
+    "dpr",
+    "pl",
+    "pm",
+    "pod",
+    "t",
+    "PL",
+    "php",
+    "php3",
+    "php4",
+    "php5",
+    "php7",
+    "phps",
+    "phpt",
+    "phtml",
+    "txt",
+    "ps1",
+    "psm1",
+    "psd1",
+    "proto",
+    "protodevel",
+    "pb.txt",
+    "proto.text",
+    "textpb",
+    "pbtxt",
+    "prototxt",
+    "pp",
+    "epp",
+    "purs",
+    "py",
+    "py3",
+    "pyw",
+    "pyi",
+    "pyx",
+    "pyx.in",
+    "pxd",
+    "pxd.in",
+    "pxi",
+    "pxi.in",
+    "rpy",
+    "cpy",
+    "SConstruct",
+    "Sconstruct",
+    "sconstruct",
+    "SConscript",
+    "gyp",
+    "gypi",
+    "Snakefile",
+    "wscript",
+    "R",
+    "r",
+    "s",
+    "S",
+    "Rprofile",
+    "rd",
+    "re",
+    "rst",
+    "rest",
+    "robot",
+    "rb",
+    "Appfile",
+    "Appraisals",
+    "Berksfile",
+    "Brewfile",
+    "capfile",
+    "cgi",
+    "Cheffile",
+    "config.ru",
+    "Deliverfile",
+    "Fastfile",
+    "fcgi",
+    "Gemfile",
+    "gemspec",
+    "Guardfile",
+    "irbrc",
+    "jbuilder",
+    "Podfile",
+    "podspec",
+    "prawn",
+    "rabl",
+    "rake",
+    "Rakefile",
+    "Rantfile",
+    "rbx",
+    "rjs",
+    "ruby.rail",
+    "Scanfile",
+    "simplecov",
+    "Snapfile",
+    "thor",
+    "Thorfile",
+    "Vagrantfile",
+    "haml",
+    "sass",
+    "rxml",
+    "builder",
+    "rs",
+    "scala",
+    "sbt",
+    "sql",
+    "ddl",
+    "dml",
+    "erbsql",
+    "sql.erb",
+    "swift",
+    "log",
+    "tcl",
+    "tf",
+    "tfvars",
+    "hcl",
+    "sty",
+    "cls",
+    "textile",
+    "toml",
+    "tml",
+    "Cargo.lock",
+    "Gopkg.lock",
+    "Pipfile",
+    "ts",
+    "tsx",
+    "varlink",
+    "vim",
+    ".vimrc",
+    "xml",
+    "xsd",
+    "xslt",
+    "tld",
+    "dtml",
+    "rss",
+    "opml",
+    "svg",
+    "yaml",
+    "yml",
+    "sublime-syntax",
+];

crates/nu-command/src/commands/count.rs

@@ -0,0 +1,86 @@
+use crate::prelude::*;
+use futures::stream::StreamExt;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, UntaggedValue, Value};
+
+pub struct Count;
+
+#[derive(Deserialize)]
+pub struct CountArgs {
+    column: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Count {
+    fn name(&self) -> &str {
+        "count"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("count").switch(
+            "column",
+            "Calculate number of columns in table",
+            Some('c'),
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Show the total number of rows or items."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let (CountArgs { column }, input) = args.process().await?;
+        let rows: Vec<Value> = input.collect().await;
+
+        let count = if column {
+            if rows.is_empty() {
+                0
+            } else {
+                match &rows[0].value {
+                    UntaggedValue::Row(dictionary) => dictionary.length(),
+                    _ => {
+                        return Err(ShellError::labeled_error(
+                            "Cannot obtain column count",
+                            "cannot obtain column count",
+                            tag,
+                        ));
+                    }
+                }
+            }
+        } else {
+            rows.len()
+        };
+
+        Ok(OutputStream::one(UntaggedValue::int(count).into_value(tag)))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Count the number of entries in a list",
+                example: "echo [1 2 3 4 5] | count",
+                result: Some(vec![UntaggedValue::int(5).into()]),
+            },
+            Example {
+                description: "Count the number of columns in the calendar table",
+                example: "cal | count -c",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Count;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Count {})?)
+    }
+}

crates/nu-command/src/commands/cp.rs

@@ -0,0 +1,63 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape};
+
+pub struct Cpy;
+
+#[async_trait]
+impl WholeStreamCommand for Cpy {
+    fn name(&self) -> &str {
+        "cp"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("cp")
+            .required("src", SyntaxShape::GlobPattern, "the place to copy from")
+            .required("dst", SyntaxShape::FilePath, "the place to copy to")
+            .switch(
+                "recursive",
+                "copy recursively through subdirectories",
+                Some('r'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Copy files."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let shell_manager = args.shell_manager.clone();
+        let name = args.call_info.name_tag.clone();
+        let (args, _) = args.process().await?;
+        shell_manager.cp(args, name)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Copy myfile to dir_b",
+                example: "cp myfile dir_b",
+                result: None,
+            },
+            Example {
+                description: "Recursively copy dir_a to dir_b",
+                example: "cp -r dir_a dir_b",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Cpy;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Cpy {})?)
+    }
+}

crates/nu-command/src/commands/date/command.rs

@@ -0,0 +1,40 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "date"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date")
+    }
+
+    fn usage(&self) -> &str {
+        "Apply date function"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(get_help(&Command, &args.scope)).into_value(Tag::unknown()),
+        )))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Command;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Command {})?)
+    }
+}

crates/nu-command/src/commands/date/format.rs

@@ -0,0 +1,109 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    Dictionary, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+use std::fmt::{self, write};
+
+pub struct Date;
+
+#[derive(Deserialize)]
+pub struct FormatArgs {
+    format: Tagged<String>,
+    table: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date format"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date format")
+            .required("format", SyntaxShape::String, "strftime format")
+            .switch("table", "print date in a table", Some('t'))
+    }
+
+    fn usage(&self) -> &str {
+        "Format a given date using the given format string."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        format(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Format the current date",
+                example: "date now | date format '%Y.%m.%d_%H %M %S,%z'",
+                result: None,
+            },
+            Example {
+                description: "Format the current date and print in a table",
+                example: "date now | date format -t '%Y-%m-%d_%H:%M:%S %z'",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn format(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let (FormatArgs { format, table }, input) = args.process().await?;
+
+    Ok(input
+        .map(move |value| match value {
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Date(dt)),
+                ..
+            } => {
+                let mut output = String::new();
+                if let Err(fmt::Error) =
+                    write(&mut output, format_args!("{}", dt.format(&format.item)))
+                {
+                    Err(ShellError::labeled_error(
+                        "The date format is invalid",
+                        "invalid strftime format",
+                        &format.tag,
+                    ))
+                } else {
+                    let value = if table {
+                        let mut indexmap = IndexMap::new();
+                        indexmap.insert(
+                            "formatted".to_string(),
+                            UntaggedValue::string(&output).into_value(&tag),
+                        );
+
+                        UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag)
+                    } else {
+                        UntaggedValue::string(&output).into_value(&tag)
+                    };
+
+                    ReturnSuccess::value(value)
+                }
+            }
+            _ => Err(ShellError::labeled_error(
+                "Expected a date from pipeline",
+                "requires date input",
+                &tag,
+            )),
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-command/src/commands/date/list_timezone.rs

@@ -0,0 +1,75 @@
+use crate::prelude::*;
+use chrono_tz::TZ_VARIANTS;
+use indexmap::IndexMap;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Dictionary, ReturnSuccess, Signature, UntaggedValue};
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date list-timezone"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date list-timezone")
+    }
+
+    fn usage(&self) -> &str {
+        "List supported time zones."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        list_timezone(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "List all supported time zones",
+                example: "date list-timezone",
+                result: None,
+            },
+            Example {
+                description: "List all supported European time zones",
+                example: "date list-timezone | where timezone =~ Europe",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn list_timezone(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.call_info.name_tag.clone();
+
+    let list = TZ_VARIANTS.iter().map(move |tz| {
+        let mut entries = IndexMap::new();
+
+        entries.insert(
+            "timezone".to_string(),
+            UntaggedValue::string(tz.name()).into_value(&tag),
+        );
+
+        Ok(ReturnSuccess::Value(
+            UntaggedValue::Row(Dictionary { entries }).into_value(&tag),
+        ))
+    });
+
+    Ok(futures::stream::iter(list).to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-command/src/commands/date/mod.rs

@@ -0,0 +1,15 @@
+pub mod command;
+pub mod format;
+pub mod list_timezone;
+pub mod now;
+pub mod to_table;
+pub mod to_timezone;
+
+mod parser;
+
+pub use command::Command as Date;
+pub use format::Date as DateFormat;
+pub use list_timezone::Date as DateListTimeZone;
+pub use now::Date as DateNow;
+pub use to_table::Date as DateToTable;
+pub use to_timezone::Date as DateToTimeZone;

crates/nu-command/src/commands/date/now.rs

@@ -0,0 +1,50 @@
+use crate::prelude::*;
+use chrono::{DateTime, Local};
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, UntaggedValue};
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date now"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date now")
+    }
+
+    fn usage(&self) -> &str {
+        "Get the current date."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        now(args).await
+    }
+}
+
+pub async fn now(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.call_info.name_tag.clone();
+
+    let now: DateTime<Local> = Local::now();
+
+    let value = UntaggedValue::date(now.with_timezone(now.offset())).into_value(&tag);
+
+    Ok(OutputStream::one(value))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-command/src/commands/date/parser.rs

@@ -0,0 +1,107 @@
+// Modified from chrono::format::scan
+
+use chrono::{DateTime, FixedOffset, Local, Offset, TimeZone};
+use chrono_tz::Tz;
+use titlecase::titlecase;
+
+#[derive(Debug, Clone, PartialEq, Eq, Copy)]
+pub enum ParseErrorKind {
+    /// Given field is out of permitted range.
+    OutOfRange,
+
+    /// The input string has some invalid character sequence for given formatting items.
+    Invalid,
+
+    /// The input string has been prematurely ended.
+    TooShort,
+}
+
+pub fn datetime_in_timezone(
+    dt: &DateTime<FixedOffset>,
+    s: &str,
+) -> Result<DateTime<FixedOffset>, ParseErrorKind> {
+    match timezone_offset_internal(s, true, true) {
+        Ok(offset) => match FixedOffset::east_opt(offset) {
+            Some(offset) => Ok(dt.with_timezone(&offset)),
+            None => Err(ParseErrorKind::OutOfRange),
+        },
+        Err(ParseErrorKind::Invalid) => {
+            if s.to_lowercase() == "local" {
+                Ok(dt.with_timezone(Local::now().offset()))
+            } else {
+                let tz: Tz = parse_timezone_internal(s)?;
+                let offset = tz.offset_from_utc_datetime(&dt.naive_utc()).fix();
+                Ok(dt.with_timezone(&offset))
+            }
+        }
+        Err(e) => Err(e),
+    }
+}
+
+fn parse_timezone_internal(s: &str) -> Result<Tz, ParseErrorKind> {
+    if let Ok(tz) = s.parse() {
+        Ok(tz)
+    } else if let Ok(tz) = titlecase(s).parse() {
+        Ok(tz)
+    } else if let Ok(tz) = s.to_uppercase().parse() {
+        Ok(tz)
+    } else {
+        Err(ParseErrorKind::Invalid)
+    }
+}
+
+fn timezone_offset_internal(
+    mut s: &str,
+    consume_colon: bool,
+    allow_missing_minutes: bool,
+) -> Result<i32, ParseErrorKind> {
+    fn digits(s: &str) -> Result<(u8, u8), ParseErrorKind> {
+        let b = s.as_bytes();
+        if b.len() < 2 {
+            Err(ParseErrorKind::TooShort)
+        } else {
+            Ok((b[0], b[1]))
+        }
+    }
+    let negative = match s.as_bytes().first() {
+        Some(&b'+') => false,
+        Some(&b'-') => true,
+        Some(_) => return Err(ParseErrorKind::Invalid),
+        None => return Err(ParseErrorKind::TooShort),
+    };
+    s = &s[1..];
+
+    // hours (00--99)
+    let hours = match digits(s)? {
+        (h1 @ b'0'..=b'9', h2 @ b'0'..=b'9') => i32::from((h1 - b'0') * 10 + (h2 - b'0')),
+        _ => return Err(ParseErrorKind::Invalid),
+    };
+    s = &s[2..];
+
+    // colons (and possibly other separators)
+    if consume_colon {
+        s = s.trim_start_matches(|c: char| c == ':' || c.is_whitespace());
+    }
+
+    // minutes (00--59)
+    // if the next two items are digits then we have to add minutes
+    let minutes = if let Ok(ds) = digits(s) {
+        match ds {
+            (m1 @ b'0'..=b'5', m2 @ b'0'..=b'9') => i32::from((m1 - b'0') * 10 + (m2 - b'0')),
+            (b'6'..=b'9', b'0'..=b'9') => return Err(ParseErrorKind::OutOfRange),
+            _ => return Err(ParseErrorKind::Invalid),
+        }
+    } else if allow_missing_minutes {
+        0
+    } else {
+        return Err(ParseErrorKind::TooShort);
+    };
+    match s.len() {
+        len if len >= 2 => &s[2..],
+        len if len == 0 => s,
+        _ => return Err(ParseErrorKind::TooShort),
+    };
+
+    let seconds = hours * 3600 + minutes * 60;
+    Ok(if negative { -seconds } else { seconds })
+}

crates/nu-command/src/commands/date/to_table.rs

@@ -0,0 +1,105 @@
+use crate::prelude::*;
+use chrono::{Datelike, Timelike};
+use indexmap::IndexMap;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Dictionary, Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date to-table"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date to-table")
+    }
+
+    fn usage(&self) -> &str {
+        "Print the date in a structured table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        to_table(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Print the current date in a table",
+            example: "date now | date to-table",
+            result: None,
+        }]
+    }
+}
+
+async fn to_table(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.call_info.name_tag.clone();
+    let input = args.input;
+
+    Ok(input
+        .map(move |value| match value {
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Date(dt)),
+                ..
+            } => {
+                let mut indexmap = IndexMap::new();
+
+                indexmap.insert(
+                    "year".to_string(),
+                    UntaggedValue::int(dt.year()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "month".to_string(),
+                    UntaggedValue::int(dt.month()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "day".to_string(),
+                    UntaggedValue::int(dt.day()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "hour".to_string(),
+                    UntaggedValue::int(dt.hour()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "minute".to_string(),
+                    UntaggedValue::int(dt.minute()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "second".to_string(),
+                    UntaggedValue::int(dt.second()).into_value(&tag),
+                );
+
+                let tz = dt.offset();
+                indexmap.insert(
+                    "timezone".to_string(),
+                    UntaggedValue::string(format!("{}", tz)).into_value(&tag),
+                );
+
+                let value = UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag);
+
+                ReturnSuccess::value(value)
+            }
+            _ => Err(ShellError::labeled_error(
+                "Expected a date from pipeline",
+                "requires date input",
+                &tag,
+            )),
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-command/src/commands/date/to_timezone.rs

@@ -0,0 +1,110 @@
+use crate::commands::date::parser::{datetime_in_timezone, ParseErrorKind};
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct Date;
+
+#[derive(Deserialize)]
+struct DateToTimeZoneArgs {
+    timezone: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date to-timezone"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date to-timezone").required(
+            "time zone",
+            SyntaxShape::String,
+            "time zone description",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert a date to a given time zone.
+        
+Use `date list-timezone` to list all supported time zones.
+        "
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        to_timezone(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get the current date in UTC+05:00",
+                example: "date now | date to-timezone +0500",
+                result: None,
+            },
+            Example {
+                description: "Get the current local date",
+                example: "date now | date to-timezone local",
+                result: None,
+            },
+            Example {
+                description: "Get the current date in Hawaii",
+                example: "date now | date to-timezone US/Hawaii",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn to_timezone(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let (DateToTimeZoneArgs { timezone }, input) = args.process().await?;
+
+    Ok(input
+        .map(move |value| match value {
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Date(dt)),
+                ..
+            } => match datetime_in_timezone(&dt, &timezone.item) {
+                Ok(dt) => {
+                    let value = UntaggedValue::date(dt).into_value(&tag);
+
+                    ReturnSuccess::value(value)
+                }
+                Err(e) => Err(ShellError::labeled_error(
+                    error_message(e),
+                    "invalid time zone",
+                    &timezone.tag,
+                )),
+            },
+            _ => Err(ShellError::labeled_error(
+                "Expected a date from pipeline",
+                "requires date input",
+                &tag,
+            )),
+        })
+        .to_output_stream())
+}
+
+fn error_message(err: ParseErrorKind) -> &'static str {
+    match err {
+        ParseErrorKind::Invalid => "The time zone description is invalid",
+        ParseErrorKind::OutOfRange => "The time zone offset is out of range",
+        ParseErrorKind::TooShort => "The format of the time zone is invalid",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-command/src/commands/date/utc.rs

@@ -0,0 +1,55 @@
+use crate::prelude::*;
+use chrono::{DateTime, Utc};
+use nu_errors::ShellError;
+
+use crate::commands::date::utils::date_to_value;
+use nu_engine::WholeStreamCommand;
+use nu_protocol::Signature;
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date utc"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date utc")
+    }
+
+    fn usage(&self) -> &str {
+        "return the current date in utc."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        utc(args).await
+    }
+}
+
+pub async fn utc(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.call_info.name_tag.clone();
+
+    let no_fmt = "".to_string();
+
+    let value = {
+        let local: DateTime<Utc> = Utc::now();
+        date_to_value(local, tag, no_fmt)
+    };
+
+    Ok(OutputStream::one(value))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

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

@@ -0,0 +1,58 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct Debug;
+
+#[derive(Deserialize)]
+pub struct DebugArgs {
+    raw: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Debug {
+    fn name(&self) -> &str {
+        "debug"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("debug").switch("raw", "Prints the raw value representation.", Some('r'))
+    }
+
+    fn usage(&self) -> &str {
+        "Print the Rust debug representation of the values"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        debug_value(args).await
+    }
+}
+
+async fn debug_value(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (DebugArgs { raw }, input) = args.process().await?;
+    Ok(input
+        .map(move |v| {
+            if raw {
+                ReturnSuccess::value(
+                    UntaggedValue::string(format!("{:#?}", v)).into_untagged_value(),
+                )
+            } else {
+                ReturnSuccess::debug_value(v)
+            }
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Debug;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Debug {})?)
+    }
+}

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

@@ -0,0 +1,48 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+
+use nu_errors::ShellError;
+use nu_protocol::{hir::CapturedBlock, Signature, SyntaxShape, Value};
+use nu_source::Tagged;
+
+pub struct Def;
+
+#[derive(Deserialize)]
+pub struct DefArgs {
+    pub name: Tagged<String>,
+    pub args: Tagged<Vec<Value>>,
+    pub block: CapturedBlock,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Def {
+    fn name(&self) -> &str {
+        "def"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("def")
+            .required("name", SyntaxShape::String, "the name of the command")
+            .required(
+                "params",
+                SyntaxShape::Table,
+                "the parameters of the command",
+            )
+            .required("block", SyntaxShape::Block, "the body of the command")
+    }
+
+    fn usage(&self) -> &str {
+        "Create a command and set it to a definition."
+    }
+
+    async fn run(&self, _args: CommandArgs) -> Result<OutputStream, ShellError> {
+        // Currently, we don't do anything here because we should have already
+        // installed the definition as we entered the scope
+        // We just create a command so that we can get proper coloring
+        Ok(OutputStream::empty())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![]
+    }
+}

crates/nu-command/src/commands/default.rs

@@ -0,0 +1,85 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+use nu_value_ext::ValueExt;
+
+#[derive(Deserialize)]
+struct DefaultArgs {
+    column: Tagged<String>,
+    value: Value,
+}
+
+pub struct Default;
+
+#[async_trait]
+impl WholeStreamCommand for Default {
+    fn name(&self) -> &str {
+        "default"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("default")
+            .required("column name", SyntaxShape::String, "the name of the column")
+            .required(
+                "column value",
+                SyntaxShape::Any,
+                "the value of the column to default",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Sets a default row's column if missing."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        default(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Give a default 'target' to all file entries",
+            example: "ls -la | default target 'nothing'",
+            result: None,
+        }]
+    }
+}
+
+async fn default(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (DefaultArgs { column, value }, input) = args.process().await?;
+
+    Ok(input
+        .map(move |item| {
+            let should_add = matches!(
+                item,
+                Value {
+                    value: UntaggedValue::Row(ref r),
+                    ..
+                } if r.get_data(&column.item).borrow().is_none()
+            );
+
+            if should_add {
+                match item.insert_data_at_path(&column.item, value.clone()) {
+                    Some(new_value) => ReturnSuccess::value(new_value),
+                    None => ReturnSuccess::value(item),
+                }
+            } else {
+                ReturnSuccess::value(item)
+            }
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Default;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Default {})?)
+    }
+}

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

@@ -0,0 +1,250 @@
+use crate::prelude::*;
+use nu_engine::basic_evaluation_context;
+use nu_engine::whole_stream_command;
+use std::error::Error;
+
+pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Box<dyn Error>> {
+    let context = basic_evaluation_context()?;
+
+    {
+        use crate::commands::*;
+
+        context.add_commands(vec![
+            // Fundamentals
+            whole_stream_command(NuPlugin),
+            whole_stream_command(Let),
+            whole_stream_command(LetEnv),
+            whole_stream_command(Def),
+            whole_stream_command(Source),
+            // System/file operations
+            whole_stream_command(Exec),
+            whole_stream_command(Pwd),
+            whole_stream_command(Ls),
+            whole_stream_command(Du),
+            whole_stream_command(Cd),
+            whole_stream_command(Remove),
+            whole_stream_command(Open),
+            whole_stream_command(Config),
+            whole_stream_command(ConfigGet),
+            whole_stream_command(ConfigSet),
+            whole_stream_command(ConfigSetInto),
+            whole_stream_command(ConfigClear),
+            whole_stream_command(ConfigLoad),
+            whole_stream_command(ConfigRemove),
+            whole_stream_command(ConfigPath),
+            whole_stream_command(Help),
+            whole_stream_command(History),
+            whole_stream_command(Save),
+            whole_stream_command(Touch),
+            whole_stream_command(Cpy),
+            whole_stream_command(Date),
+            whole_stream_command(DateListTimeZone),
+            whole_stream_command(DateNow),
+            whole_stream_command(DateToTable),
+            whole_stream_command(DateToTimeZone),
+            whole_stream_command(DateFormat),
+            whole_stream_command(Cal),
+            whole_stream_command(Mkdir),
+            whole_stream_command(Mv),
+            whole_stream_command(Kill),
+            whole_stream_command(Version),
+            whole_stream_command(Clear),
+            whole_stream_command(Describe),
+            whole_stream_command(Which),
+            whole_stream_command(Debug),
+            whole_stream_command(WithEnv),
+            whole_stream_command(Do),
+            whole_stream_command(Sleep),
+            // Statistics
+            whole_stream_command(Size),
+            whole_stream_command(Count),
+            whole_stream_command(Benchmark),
+            // Metadata
+            whole_stream_command(Tags),
+            // Shells
+            whole_stream_command(Next),
+            whole_stream_command(Previous),
+            whole_stream_command(Shells),
+            whole_stream_command(Enter),
+            whole_stream_command(Exit),
+            // Viz
+            whole_stream_command(Chart),
+            // Viewers
+            whole_stream_command(Autoview),
+            whole_stream_command(Table),
+            // Text manipulation
+            whole_stream_command(Hash),
+            whole_stream_command(HashBase64),
+            whole_stream_command(Split),
+            whole_stream_command(SplitColumn),
+            whole_stream_command(SplitRow),
+            whole_stream_command(SplitChars),
+            whole_stream_command(Lines),
+            whole_stream_command(Echo),
+            whole_stream_command(Parse),
+            whole_stream_command(Str),
+            whole_stream_command(StrToDecimal),
+            whole_stream_command(StrToInteger),
+            whole_stream_command(StrDowncase),
+            whole_stream_command(StrUpcase),
+            whole_stream_command(StrCapitalize),
+            whole_stream_command(StrFindReplace),
+            whole_stream_command(StrFrom),
+            whole_stream_command(StrSubstring),
+            whole_stream_command(StrSet),
+            whole_stream_command(StrToDatetime),
+            whole_stream_command(StrContains),
+            whole_stream_command(StrIndexOf),
+            whole_stream_command(StrTrim),
+            whole_stream_command(StrTrimLeft),
+            whole_stream_command(StrTrimRight),
+            whole_stream_command(StrStartsWith),
+            whole_stream_command(StrEndsWith),
+            whole_stream_command(StrCollect),
+            whole_stream_command(StrLength),
+            whole_stream_command(StrLPad),
+            whole_stream_command(StrReverse),
+            whole_stream_command(StrRPad),
+            whole_stream_command(StrCamelCase),
+            whole_stream_command(StrPascalCase),
+            whole_stream_command(StrKebabCase),
+            whole_stream_command(StrSnakeCase),
+            whole_stream_command(StrScreamingSnakeCase),
+            whole_stream_command(BuildString),
+            whole_stream_command(Ansi),
+            whole_stream_command(Char),
+            // Column manipulation
+            whole_stream_command(Move),
+            whole_stream_command(Reject),
+            whole_stream_command(Select),
+            whole_stream_command(Get),
+            whole_stream_command(Update),
+            whole_stream_command(Insert),
+            whole_stream_command(IntoInt),
+            whole_stream_command(SplitBy),
+            // Row manipulation
+            whole_stream_command(Reverse),
+            whole_stream_command(Append),
+            whole_stream_command(Prepend),
+            whole_stream_command(SortBy),
+            whole_stream_command(GroupBy),
+            whole_stream_command(GroupByDate),
+            whole_stream_command(First),
+            whole_stream_command(Last),
+            whole_stream_command(Every),
+            whole_stream_command(Nth),
+            whole_stream_command(Drop),
+            whole_stream_command(Format),
+            whole_stream_command(FileSize),
+            whole_stream_command(Where),
+            whole_stream_command(If),
+            whole_stream_command(Compact),
+            whole_stream_command(Default),
+            whole_stream_command(Skip),
+            whole_stream_command(SkipUntil),
+            whole_stream_command(SkipWhile),
+            whole_stream_command(Keep),
+            whole_stream_command(KeepUntil),
+            whole_stream_command(KeepWhile),
+            whole_stream_command(Range),
+            whole_stream_command(Rename),
+            whole_stream_command(Uniq),
+            whole_stream_command(Each),
+            whole_stream_command(EachGroup),
+            whole_stream_command(EachWindow),
+            whole_stream_command(Empty),
+            // Table manipulation
+            whole_stream_command(Flatten),
+            whole_stream_command(Move),
+            whole_stream_command(Merge),
+            whole_stream_command(Shuffle),
+            whole_stream_command(Wrap),
+            whole_stream_command(Pivot),
+            whole_stream_command(Headers),
+            whole_stream_command(Reduce),
+            // Data processing
+            whole_stream_command(Histogram),
+            whole_stream_command(Autoenv),
+            whole_stream_command(AutoenvTrust),
+            whole_stream_command(AutoenvUnTrust),
+            whole_stream_command(Math),
+            whole_stream_command(MathAbs),
+            whole_stream_command(MathAverage),
+            whole_stream_command(MathEval),
+            whole_stream_command(MathMedian),
+            whole_stream_command(MathMinimum),
+            whole_stream_command(MathMode),
+            whole_stream_command(MathMaximum),
+            whole_stream_command(MathStddev),
+            whole_stream_command(MathSummation),
+            whole_stream_command(MathVariance),
+            whole_stream_command(MathProduct),
+            whole_stream_command(MathRound),
+            whole_stream_command(MathFloor),
+            whole_stream_command(MathCeil),
+            // File format output
+            whole_stream_command(To),
+            whole_stream_command(ToCSV),
+            whole_stream_command(ToHTML),
+            whole_stream_command(ToJSON),
+            whole_stream_command(ToMarkdown),
+            whole_stream_command(ToTOML),
+            whole_stream_command(ToTSV),
+            whole_stream_command(ToURL),
+            whole_stream_command(ToYAML),
+            whole_stream_command(ToXML),
+            // File format input
+            whole_stream_command(From),
+            whole_stream_command(FromCSV),
+            whole_stream_command(FromEML),
+            whole_stream_command(FromTSV),
+            whole_stream_command(FromSSV),
+            whole_stream_command(FromINI),
+            whole_stream_command(FromJSON),
+            whole_stream_command(FromODS),
+            whole_stream_command(FromTOML),
+            whole_stream_command(FromURL),
+            whole_stream_command(FromXLSX),
+            whole_stream_command(FromXML),
+            whole_stream_command(FromYAML),
+            whole_stream_command(FromYML),
+            whole_stream_command(FromIcs),
+            whole_stream_command(FromVcf),
+            // "Private" commands (not intended to be accessed directly)
+            whole_stream_command(RunExternalCommand { interactive }),
+            // Random value generation
+            whole_stream_command(Random),
+            whole_stream_command(RandomBool),
+            whole_stream_command(RandomDice),
+            #[cfg(feature = "uuid_crate")]
+            whole_stream_command(RandomUUID),
+            whole_stream_command(RandomInteger),
+            whole_stream_command(RandomDecimal),
+            whole_stream_command(RandomChars),
+            // Path
+            whole_stream_command(PathBasename),
+            whole_stream_command(PathCommand),
+            whole_stream_command(PathDirname),
+            whole_stream_command(PathExists),
+            whole_stream_command(PathExpand),
+            whole_stream_command(PathExtension),
+            whole_stream_command(PathFilestem),
+            whole_stream_command(PathType),
+            // Url
+            whole_stream_command(UrlCommand),
+            whole_stream_command(UrlScheme),
+            whole_stream_command(UrlPath),
+            whole_stream_command(UrlHost),
+            whole_stream_command(UrlQuery),
+            whole_stream_command(Seq),
+            whole_stream_command(SeqDates),
+        ]);
+
+        #[cfg(feature = "clipboard-cli")]
+        {
+            context.add_commands(vec![whole_stream_command(crate::commands::clip::Clip)]);
+        }
+    }
+
+    Ok(context)
+}

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

@@ -0,0 +1,54 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct Describe;
+
+#[derive(Deserialize)]
+pub struct DescribeArgs {}
+
+#[async_trait]
+impl WholeStreamCommand for Describe {
+    fn name(&self) -> &str {
+        "describe"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("describe")
+    }
+
+    fn usage(&self) -> &str {
+        "Describes the objects in the stream."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        describe(args).await
+    }
+}
+
+pub async fn describe(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    Ok(args
+        .input
+        .map(|row| {
+            let name = value::format_type(&row, 100);
+            ReturnSuccess::value(
+                UntaggedValue::string(name).into_value(Tag::unknown_anchor(row.tag.span)),
+            )
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Describe;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Describe {})?)
+    }
+}

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

@@ -0,0 +1,118 @@
+use crate::prelude::*;
+use nu_engine::run_block;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{hir::CapturedBlock, hir::ExternalRedirection, Signature, SyntaxShape, Value};
+
+pub struct Do;
+
+#[derive(Deserialize, Debug)]
+struct DoArgs {
+    block: CapturedBlock,
+    ignore_errors: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Do {
+    fn name(&self) -> &str {
+        "do"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("do")
+            .required("block", SyntaxShape::Block, "the block to run ")
+            .switch(
+                "ignore_errors",
+                "ignore errors as the block runs",
+                Some('i'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block, optionally ignoring errors"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        do_(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Run the block",
+                example: r#"do { echo hello }"#,
+                result: Some(vec![Value::from("hello")]),
+            },
+            Example {
+                description: "Run the block and ignore errors",
+                example: r#"do -i { thisisnotarealcommand }"#,
+                result: Some(vec![]),
+            },
+        ]
+    }
+}
+
+async fn do_(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let external_redirection = raw_args.call_info.args.external_redirection;
+
+    let context = EvaluationContext::from_raw(&raw_args);
+    let (
+        DoArgs {
+            ignore_errors,
+            mut block,
+        },
+        input,
+    ) = raw_args.process().await?;
+
+    let block_redirection = match external_redirection {
+        ExternalRedirection::None => {
+            if ignore_errors {
+                ExternalRedirection::Stderr
+            } else {
+                ExternalRedirection::None
+            }
+        }
+        ExternalRedirection::Stdout => {
+            if ignore_errors {
+                ExternalRedirection::StdoutAndStderr
+            } else {
+                ExternalRedirection::Stdout
+            }
+        }
+        x => x,
+    };
+
+    block.block.set_redirect(block_redirection);
+    context.scope.enter_scope();
+    let result = run_block(&block.block, &context, input).await;
+    context.scope.exit_scope();
+
+    if ignore_errors {
+        // To properly ignore errors we need to redirect stderr, consume it, and remove
+        // any errors we see in the process.
+
+        match result {
+            Ok(mut stream) => {
+                let output = stream.drain_vec().await;
+                context.clear_errors();
+                Ok(futures::stream::iter(output).to_output_stream())
+            }
+            Err(_) => Ok(OutputStream::empty()),
+        }
+    } else {
+        result.map(|x| x.to_output_stream())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Do;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Do {})?)
+    }
+}

crates/nu-command/src/commands/drop.rs

@@ -0,0 +1,91 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct Drop;
+
+#[derive(Deserialize)]
+pub struct DropArgs {
+    rows: Option<Tagged<u64>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Drop {
+    fn name(&self) -> &str {
+        "drop"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("drop").optional(
+            "rows",
+            SyntaxShape::Number,
+            "starting from the back, the number of rows to remove",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Remove the last number of rows. If you want to remove columns, try 'reject'."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        drop(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Remove the last item of a list/table",
+                example: "echo [1 2 3] | drop",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(2).into(),
+                ]),
+            },
+            Example {
+                description: "Remove the last 2 items of a list/table",
+                example: "echo [1 2 3] | drop 2",
+                result: Some(vec![UntaggedValue::int(1).into()]),
+            },
+        ]
+    }
+}
+
+async fn drop(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (DropArgs { rows }, input) = args.process().await?;
+    let v: Vec<_> = input.into_vec().await;
+
+    let rows_to_drop = if let Some(quantity) = rows {
+        *quantity as usize
+    } else {
+        1
+    };
+
+    Ok(if rows_to_drop == 0 {
+        futures::stream::iter(v).to_output_stream()
+    } else {
+        let k = if v.len() < rows_to_drop {
+            0
+        } else {
+            v.len() - rows_to_drop
+        };
+
+        let iter = v.into_iter().take(k);
+
+        futures::stream::iter(iter).to_output_stream()
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Drop;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Drop {})?)
+    }
+}

crates/nu-command/src/commands/du.rs

@@ -0,0 +1,173 @@
+use crate::prelude::*;
+use glob::*;
+use nu_engine::WholeStreamCommand;
+use nu_engine::{DirBuilder, DirInfo, FileInfo};
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape};
+use nu_source::Tagged;
+use std::path::PathBuf;
+
+const NAME: &str = "du";
+const GLOB_PARAMS: MatchOptions = MatchOptions {
+    case_sensitive: true,
+    require_literal_separator: true,
+    require_literal_leading_dot: false,
+};
+
+pub struct Du;
+
+#[derive(Deserialize, Clone)]
+pub struct DuArgs {
+    path: Option<Tagged<PathBuf>>,
+    all: bool,
+    deref: bool,
+    exclude: Option<Tagged<String>>,
+    #[serde(rename = "max-depth")]
+    max_depth: Option<Tagged<u64>>,
+    #[serde(rename = "min-size")]
+    min_size: Option<Tagged<u64>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Du {
+    fn name(&self) -> &str {
+        NAME
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(NAME)
+            .optional("path", SyntaxShape::GlobPattern, "starting directory")
+            .switch(
+                "all",
+                "Output file sizes as well as directory sizes",
+                Some('a'),
+            )
+            .switch(
+                "deref",
+                "Dereference symlinks to their targets for size",
+                Some('r'),
+            )
+            .named(
+                "exclude",
+                SyntaxShape::GlobPattern,
+                "Exclude these file names",
+                Some('x'),
+            )
+            .named(
+                "max-depth",
+                SyntaxShape::Int,
+                "Directory recursion limit",
+                Some('d'),
+            )
+            .named(
+                "min-size",
+                SyntaxShape::Int,
+                "Exclude files below this size",
+                Some('m'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Find disk usage sizes of specified items"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        du(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Disk usage of the current directory",
+            example: "du",
+            result: None,
+        }]
+    }
+}
+
+async fn du(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let ctrl_c = args.ctrl_c.clone();
+    let ctrl_c_copy = ctrl_c.clone();
+
+    let (args, _): (DuArgs, _) = args.process().await?;
+    let exclude = args.exclude.map_or(Ok(None), move |x| {
+        Pattern::new(&x.item)
+            .map(Option::Some)
+            .map_err(|e| ShellError::labeled_error(e.msg, "glob error", x.tag.clone()))
+    })?;
+
+    let include_files = args.all;
+    let paths = match args.path {
+        Some(p) => {
+            let p = p.item.to_str().expect("Why isn't this encoded properly?");
+            glob::glob_with(p, GLOB_PARAMS)
+        }
+        None => glob::glob_with("*", GLOB_PARAMS),
+    }
+    .map_err(|e| ShellError::labeled_error(e.msg, "glob error", tag.clone()))?
+    .filter(move |p| {
+        if include_files {
+            true
+        } else {
+            match p {
+                Ok(f) if f.is_dir() => true,
+                Err(e) if e.path().is_dir() => true,
+                _ => false,
+            }
+        }
+    })
+    .map(|v| v.map_err(glob_err_into));
+
+    let all = args.all;
+    let deref = args.deref;
+    let max_depth = args.max_depth.map(|f| f.item);
+    let min_size = args.min_size.map(|f| f.item);
+
+    let params = DirBuilder {
+        tag: tag.clone(),
+        min: min_size,
+        deref,
+        exclude,
+        all,
+    };
+
+    let inp = futures::stream::iter(paths);
+
+    Ok(inp
+        .flat_map(move |path| match path {
+            Ok(p) => {
+                let mut output = vec![];
+                if p.is_dir() {
+                    output.push(Ok(ReturnSuccess::Value(
+                        DirInfo::new(p, &params, max_depth, ctrl_c.clone()).into(),
+                    )));
+                } else {
+                    for v in FileInfo::new(p, deref, tag.clone()).into_iter() {
+                        output.push(Ok(ReturnSuccess::Value(v.into())));
+                    }
+                }
+                futures::stream::iter(output)
+            }
+            Err(e) => futures::stream::iter(vec![Err(e)]),
+        })
+        .interruptible(ctrl_c_copy)
+        .to_output_stream())
+}
+
+fn glob_err_into(e: GlobError) -> ShellError {
+    let e = e.into_error();
+    ShellError::from(e)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Du;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Du {})?)
+    }
+}

crates/nu-command/src/commands/each/command.rs

@@ -0,0 +1,165 @@
+use crate::prelude::*;
+use nu_engine::run_block;
+use nu_engine::WholeStreamCommand;
+
+use futures::stream::once;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::CapturedBlock, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+
+pub struct Each;
+
+#[derive(Deserialize)]
+pub struct EachArgs {
+    block: CapturedBlock,
+    numbered: Tagged<bool>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Each {
+    fn name(&self) -> &str {
+        "each"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("each")
+            .required("block", SyntaxShape::Block, "the block to run on each row")
+            .switch(
+                "numbered",
+                "returned a numbered item ($it.index and $it.item)",
+                Some('n'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Run a block on each row of the table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        each(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Echo the sum of each row",
+                example: "echo [[1 2] [3 4]] | each { echo $it | math sum }",
+                result: None,
+            },
+            Example {
+                description: "Echo the square of each integer",
+                example: "echo [1 2 3] | each { echo $(= $it * $it) }",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(4).into(),
+                    UntaggedValue::int(9).into(),
+                ]),
+            },
+            Example {
+                description: "Number each item and echo a message",
+                example:
+                    "echo ['bob' 'fred'] | each --numbered { echo `{{$it.index}} is {{$it.item}}` }",
+                result: Some(vec![Value::from("0 is bob"), Value::from("1 is fred")]),
+            },
+        ]
+    }
+}
+
+pub async fn process_row(
+    captured_block: Arc<Box<CapturedBlock>>,
+    context: Arc<EvaluationContext>,
+    input: Value,
+) -> Result<OutputStream, ShellError> {
+    let input_clone = input.clone();
+    // When we process a row, we need to know whether the block wants to have the contents of the row as
+    // a parameter to the block (so it gets assigned to a variable that can be used inside the block) or
+    // if it wants the contents as as an input stream
+
+    let input_stream = if !captured_block.block.params.positional.is_empty() {
+        InputStream::empty()
+    } else {
+        once(async { Ok(input_clone) }).to_input_stream()
+    };
+
+    context.scope.enter_scope();
+    context.scope.add_vars(&captured_block.captured.entries);
+
+    if !captured_block.block.params.positional.is_empty() {
+        // FIXME: add check for more than parameter, once that's supported
+        context
+            .scope
+            .add_var(captured_block.block.params.positional[0].0.name(), input);
+    } else {
+        context.scope.add_var("$it", input);
+    }
+
+    let result = run_block(&captured_block.block, &*context, input_stream).await;
+
+    context.scope.exit_scope();
+
+    Ok(result?.to_output_stream())
+}
+
+pub(crate) fn make_indexed_item(index: usize, item: Value) -> Value {
+    let mut dict = TaggedDictBuilder::new(item.tag());
+    dict.insert_untagged("index", UntaggedValue::int(index));
+    dict.insert_value("item", item);
+
+    dict.into_value()
+}
+
+async fn each(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let context = Arc::new(EvaluationContext::from_raw(&raw_args));
+
+    let (each_args, input): (EachArgs, _) = raw_args.process().await?;
+    let block = Arc::new(Box::new(each_args.block));
+
+    if each_args.numbered.item {
+        Ok(input
+            .enumerate()
+            .then(move |input| {
+                let block = block.clone();
+                let context = context.clone();
+                let row = make_indexed_item(input.0, input.1);
+
+                async {
+                    match process_row(block, context, row).await {
+                        Ok(s) => s,
+                        Err(e) => OutputStream::one(Err(e)),
+                    }
+                }
+            })
+            .flatten()
+            .to_output_stream())
+    } else {
+        Ok(input
+            .then(move |input| {
+                let block = block.clone();
+                let context = context.clone();
+
+                async {
+                    match process_row(block, context, input).await {
+                        Ok(s) => s,
+                        Err(e) => OutputStream::one(Err(e)),
+                    }
+                }
+            })
+            .flatten()
+            .to_output_stream())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Each;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Each {})?)
+    }
+}

crates/nu-command/src/commands/each/group.rs

@@ -0,0 +1,116 @@
+use crate::commands::each::process_row;
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::CapturedBlock, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+use serde::Deserialize;
+
+pub struct EachGroup;
+
+#[derive(Deserialize)]
+pub struct EachGroupArgs {
+    group_size: Tagged<usize>,
+    block: CapturedBlock,
+    //numbered: Tagged<bool>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for EachGroup {
+    fn name(&self) -> &str {
+        "each group"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("each group")
+            .required("group_size", SyntaxShape::Int, "the size of each group")
+            .required(
+                "block",
+                SyntaxShape::Block,
+                "the block to run on each group",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block on groups of `group_size` rows of a table at a time."
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Echo the sum of each pair",
+            example: "echo [1 2 3 4] | each group 2 { echo $it | math sum }",
+            result: None,
+        }]
+    }
+
+    async fn run(&self, raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let context = Arc::new(EvaluationContext::from_raw(&raw_args));
+        let (each_args, input): (EachGroupArgs, _) = raw_args.process().await?;
+        let block = Arc::new(Box::new(each_args.block));
+
+        Ok(input
+            .chunks(each_args.group_size.item)
+            .then(move |input| run_block_on_vec(input, block.clone(), context.clone()))
+            .flatten()
+            .to_output_stream())
+    }
+}
+
+pub(crate) fn run_block_on_vec(
+    input: Vec<Value>,
+    block: Arc<Box<CapturedBlock>>,
+    context: Arc<EvaluationContext>,
+) -> impl Future<Output = OutputStream> {
+    let value = Value {
+        value: UntaggedValue::Table(input),
+        tag: Tag::unknown(),
+    };
+
+    async {
+        match process_row(block, context, value).await {
+            Ok(s) => {
+                // We need to handle this differently depending on whether process_row
+                // returned just 1 value or if it returned multiple as a stream.
+                let vec = s.collect::<Vec<_>>().await;
+
+                // If it returned just one value, just take that value
+                if vec.len() == 1 {
+                    return OutputStream::one(vec.into_iter().next().expect(
+                        "This should be impossible, we just checked that vec.len() == 1.",
+                    ));
+                }
+
+                // If it returned multiple values, we need to put them into a table and
+                // return that.
+                let result = vec.into_iter().collect::<Result<Vec<ReturnSuccess>, _>>();
+                let result_table = match result {
+                    Ok(t) => t,
+                    Err(e) => return OutputStream::one(Err(e)),
+                };
+
+                let table = result_table
+                    .into_iter()
+                    .filter_map(|x| x.raw_value())
+                    .collect();
+
+                OutputStream::one(Ok(ReturnSuccess::Value(UntaggedValue::Table(table).into())))
+            }
+            Err(e) => OutputStream::one(Err(e)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EachGroup;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(EachGroup {})?)
+    }
+}

crates/nu-command/src/commands/each/mod.rs

@@ -0,0 +1,9 @@
+pub mod command;
+pub mod group;
+pub mod window;
+
+pub(crate) use command::make_indexed_item;
+pub use command::process_row;
+pub use command::Each;
+pub use group::EachGroup;
+pub use window::EachWindow;

crates/nu-command/src/commands/each/window.rs

@@ -0,0 +1,105 @@
+use crate::commands::each::group::run_block_on_vec;
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+//use itertools::Itertools;
+use nu_errors::ShellError;
+use nu_protocol::{hir::CapturedBlock, Primitive, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+use serde::Deserialize;
+
+pub struct EachWindow;
+
+#[derive(Deserialize)]
+pub struct EachWindowArgs {
+    window_size: Tagged<usize>,
+    block: CapturedBlock,
+    stride: Option<Tagged<usize>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for EachWindow {
+    fn name(&self) -> &str {
+        "each window"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("each window")
+            .required("window_size", SyntaxShape::Int, "the size of each window")
+            .named(
+                "stride",
+                SyntaxShape::Int,
+                "the number of rows to slide over between windows",
+                Some('s'),
+            )
+            .required(
+                "block",
+                SyntaxShape::Block,
+                "the block to run on each group",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block on sliding windows of `window_size` rows of a table at a time."
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Echo the sum of each window",
+            example: "echo [1 2 3 4] | each window 2 { echo $it | math sum }",
+            result: None,
+        }]
+    }
+
+    async fn run(&self, raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let context = Arc::new(EvaluationContext::from_raw(&raw_args));
+        let (each_args, mut input): (EachWindowArgs, _) = raw_args.process().await?;
+        let block = Arc::new(Box::new(each_args.block));
+
+        let mut window: Vec<_> = input
+            .by_ref()
+            .take(*each_args.window_size - 1)
+            .collect::<Vec<_>>()
+            .await;
+
+        // `window` must start with dummy values, which will be removed on the first iteration
+        let stride = each_args.stride.map(|x| *x).unwrap_or(1);
+        window.insert(0, UntaggedValue::Primitive(Primitive::Nothing).into());
+
+        Ok(input
+            .enumerate()
+            .then(move |(i, input)| {
+                // This would probably be more efficient if `last` was a VecDeque
+                // But we can't have that because it needs to be put into a Table
+                window.remove(0);
+                window.push(input);
+
+                let block = block.clone();
+                let context = context.clone();
+                let local_window = window.clone();
+
+                async move {
+                    if i % stride == 0 {
+                        Some(run_block_on_vec(local_window, block, context).await)
+                    } else {
+                        None
+                    }
+                }
+            })
+            .filter_map(|x| async { x })
+            .flatten()
+            .to_output_stream())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EachWindow;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(EachWindow {})?)
+    }
+}

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

@@ -0,0 +1,168 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::hir::Operator;
+use nu_protocol::{
+    Primitive, Range, RangeInclusion, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+
+pub struct Echo;
+
+#[derive(Deserialize, Debug)]
+pub struct EchoArgs {
+    pub rest: Vec<Value>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Echo {
+    fn name(&self) -> &str {
+        "echo"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("echo").rest(SyntaxShape::Any, "the values to echo")
+    }
+
+    fn usage(&self) -> &str {
+        "Echo the arguments back to the user."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        echo(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Put a hello message in the pipeline",
+                example: "echo 'hello'",
+                result: Some(vec![Value::from("hello")]),
+            },
+            Example {
+                description: "Print the value of the special '$nu' variable",
+                example: "echo $nu",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn echo(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (args, _): (EchoArgs, _) = args.process().await?;
+
+    let stream = args.rest.into_iter().map(|i| match i.as_string() {
+        Ok(s) => OutputStream::one(Ok(ReturnSuccess::Value(
+            UntaggedValue::string(s).into_value(i.tag.clone()),
+        ))),
+        _ => match i {
+            Value {
+                value: UntaggedValue::Table(table),
+                ..
+            } => futures::stream::iter(table.into_iter().map(ReturnSuccess::value))
+                .to_output_stream(),
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Range(range)),
+                tag,
+            } => futures::stream::iter(RangeIterator::new(*range, tag)).to_output_stream(),
+            x => OutputStream::one(Ok(ReturnSuccess::Value(x))),
+        },
+    });
+
+    Ok(futures::stream::iter(stream).flatten().to_output_stream())
+}
+
+struct RangeIterator {
+    curr: Primitive,
+    end: Primitive,
+    tag: Tag,
+    is_end_inclusive: bool,
+}
+
+impl RangeIterator {
+    pub fn new(range: Range, tag: Tag) -> RangeIterator {
+        let start = match range.from.0.item {
+            Primitive::Nothing => Primitive::Int(0.into()),
+            x => x,
+        };
+
+        RangeIterator {
+            curr: start,
+            end: range.to.0.item,
+            tag,
+            is_end_inclusive: matches!(range.to.1, RangeInclusion::Inclusive),
+        }
+    }
+}
+
+impl Iterator for RangeIterator {
+    type Item = Result<ReturnSuccess, ShellError>;
+    fn next(&mut self) -> Option<Self::Item> {
+        let ordering = if self.end == Primitive::Nothing {
+            Ordering::Less
+        } else {
+            let result =
+                nu_data::base::coerce_compare_primitive(&self.curr, &self.end).map_err(|_| {
+                    ShellError::labeled_error(
+                        "Cannot create range",
+                        "unsupported range",
+                        self.tag.span,
+                    )
+                });
+
+            if let Err(result) = result {
+                return Some(Err(result));
+            }
+
+            let result = result
+                .expect("Internal error: the error case was already protected, but that failed");
+
+            result.compare()
+        };
+
+        use std::cmp::Ordering;
+
+        if (ordering == Ordering::Less) || (self.is_end_inclusive && ordering == Ordering::Equal) {
+            let output = UntaggedValue::Primitive(self.curr.clone()).into_value(self.tag.clone());
+
+            let next_value = nu_data::value::compute_values(
+                Operator::Plus,
+                &UntaggedValue::Primitive(self.curr.clone()),
+                &UntaggedValue::int(1),
+            );
+
+            self.curr = match next_value {
+                Ok(result) => match result {
+                    UntaggedValue::Primitive(p) => p,
+                    _ => {
+                        return Some(Err(ShellError::unimplemented(
+                            "Internal error: expected a primitive result from increment",
+                        )));
+                    }
+                },
+                Err((left_type, right_type)) => {
+                    return Some(Err(ShellError::coerce_error(
+                        left_type.spanned(self.tag.span),
+                        right_type.spanned(self.tag.span),
+                    )));
+                }
+            };
+            Some(ReturnSuccess::value(output))
+        } else {
+            // TODO: add inclusive/exclusive ranges
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Echo;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Echo {})?)
+    }
+}

crates/nu-command/src/commands/empty.rs

@@ -0,0 +1,275 @@
+use crate::prelude::*;
+use nu_engine::run_block;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::CapturedBlock, ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape,
+    UntaggedValue, Value,
+};
+use nu_source::Tagged;
+use nu_value_ext::{as_string, ValueExt};
+
+use futures::stream::once;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    rest: Vec<Value>,
+}
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "empty?"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("empty?").rest(
+            SyntaxShape::Any,
+            "the names of the columns to check emptiness. Pass an optional block to replace if empty",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Check for empty values"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        is_empty(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Check if a value is empty",
+                example: "echo '' | empty?",
+                result: Some(vec![UntaggedValue::boolean(true).into()]),
+            },
+            Example {
+                description: "more than one column",
+                example: "echo [[meal size]; [arepa small] [taco '']] | empty? meal size",
+                result: Some(
+                    vec![
+                        UntaggedValue::row(indexmap! {
+                                "meal".to_string() => Value::from(false),
+                                "size".to_string() => Value::from(false),
+                        })
+                        .into(),
+                        UntaggedValue::row(indexmap! {
+                                "meal".to_string() => Value::from(false),
+                                "size".to_string() => Value::from(true),
+                        })
+                        .into(),
+                    ],
+                ),
+            },Example {
+                description: "use a block if setting the empty cell contents is wanted",
+                example: "echo [[2020/04/16 2020/07/10 2020/11/16]; ['' [27] [37]]] | empty? 2020/04/16 { = [33 37] }",
+                result: Some(
+                    vec![
+                        UntaggedValue::row(indexmap! {
+                                "2020/04/16".to_string() => UntaggedValue::table(&[UntaggedValue::int(33).into(), UntaggedValue::int(37).into()]).into(),
+                                "2020/07/10".to_string() => UntaggedValue::table(&[UntaggedValue::int(27).into()]).into(),
+                                "2020/11/16".to_string() => UntaggedValue::table(&[UntaggedValue::int(37).into()]).into(),
+                        })
+                        .into(),
+                    ],
+                ),
+            },
+        ]
+    }
+}
+
+async fn is_empty(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let name_tag = Arc::new(args.call_info.name_tag.clone());
+    let context = Arc::new(EvaluationContext::from_raw(&args));
+    let (Arguments { rest }, input) = args.process().await?;
+    let (columns, default_block): (Vec<ColumnPath>, Option<Box<CapturedBlock>>) = arguments(rest)?;
+    let default_block = Arc::new(default_block);
+
+    if input.is_empty() {
+        let stream = futures::stream::iter(vec![
+            UntaggedValue::Primitive(Primitive::Nothing).into_value(tag)
+        ]);
+
+        return Ok(InputStream::from_stream(stream)
+            .then(move |input| {
+                let tag = name_tag.clone();
+                let context = context.clone();
+                let block = default_block.clone();
+                let columns = vec![];
+
+                async {
+                    match process_row(context, input, block, columns, tag).await {
+                        Ok(s) => s,
+                        Err(e) => OutputStream::one(Err(e)),
+                    }
+                }
+            })
+            .flatten()
+            .to_output_stream());
+    }
+
+    Ok(input
+        .then(move |input| {
+            let tag = name_tag.clone();
+            let context = context.clone();
+            let block = default_block.clone();
+            let columns = columns.clone();
+
+            async {
+                match process_row(context, input, block, columns, tag).await {
+                    Ok(s) => s,
+                    Err(e) => OutputStream::one(Err(e)),
+                }
+            }
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+fn arguments(
+    rest: Vec<Value>,
+) -> Result<(Vec<ColumnPath>, Option<Box<CapturedBlock>>), ShellError> {
+    let mut rest = rest;
+    let mut columns = vec![];
+    let mut default = None;
+
+    let last_argument = rest.pop();
+
+    match last_argument {
+        Some(Value {
+            value: UntaggedValue::Block(call),
+            ..
+        }) => default = Some(call),
+        Some(other) => {
+            let Tagged { item: path, .. } = other.as_column_path()?;
+
+            columns = vec![path];
+        }
+        None => {}
+    };
+
+    for argument in rest {
+        let Tagged { item: path, .. } = argument.as_column_path()?;
+
+        columns.push(path);
+    }
+
+    Ok((columns, default))
+}
+
+async fn process_row(
+    context: Arc<EvaluationContext>,
+    input: Value,
+    default_block: Arc<Option<Box<CapturedBlock>>>,
+    column_paths: Vec<ColumnPath>,
+    tag: Arc<Tag>,
+) -> Result<OutputStream, ShellError> {
+    let _tag = &*tag;
+    let mut out = Arc::new(None);
+    let results = Arc::make_mut(&mut out);
+
+    if let Some(default_block) = &*default_block {
+        let for_block = input.clone();
+        let input_stream = once(async { Ok(for_block) }).to_input_stream();
+
+        context.scope.enter_scope();
+        context.scope.add_vars(&default_block.captured.entries);
+        context.scope.add_var("$it", input.clone());
+
+        let stream = run_block(&default_block.block, &*context, input_stream).await;
+        context.scope.exit_scope();
+
+        let mut stream = stream?;
+        *results = Some({
+            let values = stream.drain_vec().await;
+
+            let errors = context.get_errors();
+
+            if let Some(error) = errors.first() {
+                return Err(error.clone());
+            }
+
+            if values.len() == 1 {
+                let value = values
+                    .get(0)
+                    .ok_or_else(|| ShellError::unexpected("No value."))?;
+
+                Value {
+                    value: value.value.clone(),
+                    tag: input.tag.clone(),
+                }
+            } else if values.is_empty() {
+                UntaggedValue::nothing().into_value(&input.tag)
+            } else {
+                UntaggedValue::table(&values).into_value(&input.tag)
+            }
+        });
+    }
+
+    match input {
+        Value {
+            value: UntaggedValue::Row(ref r),
+            ref tag,
+        } => {
+            if column_paths.is_empty() {
+                Ok(OutputStream::one(ReturnSuccess::value({
+                    let is_empty = input.is_empty();
+
+                    if default_block.is_some() {
+                        if is_empty {
+                            results
+                                .clone()
+                                .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(tag))
+                        } else {
+                            input.clone()
+                        }
+                    } else {
+                        UntaggedValue::boolean(is_empty).into_value(tag)
+                    }
+                })))
+            } else {
+                let mut obj = input.clone();
+
+                for column in column_paths.clone() {
+                    let path = UntaggedValue::Primitive(Primitive::ColumnPath(column.clone()))
+                        .into_value(tag);
+                    let data = r.get_data(&as_string(&path)?).borrow().clone();
+                    let is_empty = data.is_empty();
+
+                    let default = if default_block.is_some() {
+                        if is_empty {
+                            results
+                                .clone()
+                                .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(tag))
+                        } else {
+                            data.clone()
+                        }
+                    } else {
+                        UntaggedValue::boolean(is_empty).into_value(tag)
+                    };
+
+                    if let Ok(value) =
+                        obj.swap_data_by_column_path(&column, Box::new(move |_| Ok(default)))
+                    {
+                        obj = value;
+                    }
+                }
+
+                Ok(OutputStream::one(ReturnSuccess::value(obj)))
+            }
+        }
+        other => Ok(OutputStream::one(ReturnSuccess::value({
+            if other.is_empty() {
+                results
+                    .clone()
+                    .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(other.tag))
+            } else {
+                UntaggedValue::boolean(false).into_value(other.tag)
+            }
+        }))),
+    }
+}

crates/nu-command/src/commands/enter.rs

@@ -0,0 +1,194 @@
+use crate::prelude::*;
+use nu_engine::UnevaluatedCallInfo;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::hir::ExternalRedirection;
+use nu_protocol::{
+    CommandAction, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+use std::path::PathBuf;
+
+pub struct Enter;
+
+#[derive(Deserialize)]
+pub struct EnterArgs {
+    location: Tagged<PathBuf>,
+    encoding: Option<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Enter {
+    fn name(&self) -> &str {
+        "enter"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("enter")
+            .required(
+                "location",
+                SyntaxShape::FilePath,
+                "the location to create a new shell from",
+            )
+            .named(
+                "encoding",
+                SyntaxShape::String,
+                "encoding to use to open file",
+                Some('e'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        r#"Create a new shell and begin at this path.
+        
+Multiple encodings are supported for reading text files by using
+the '--encoding <encoding>' parameter. Here is an example of a few:
+big5, euc-jp, euc-kr, gbk, iso-8859-1, utf-16, cp1252, latin5
+
+For a more complete list of encodings please refer to the encoding_rs
+documentation link at https://docs.rs/encoding_rs/0.8.23/encoding_rs/#statics"#
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        enter(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Enter a path as a new shell",
+                example: "enter ../projectB",
+                result: None,
+            },
+            Example {
+                description: "Enter a file as a new shell",
+                example: "enter package.json",
+                result: None,
+            },
+            Example {
+                description: "Enters file with iso-8859-1 encoding",
+                example: "enter file.csv --encoding iso-8859-1",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn enter(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let scope = raw_args.scope.clone();
+    let shell_manager = raw_args.shell_manager.clone();
+    let head = raw_args.call_info.args.head.clone();
+    let ctrl_c = raw_args.ctrl_c.clone();
+    let current_errors = raw_args.current_errors.clone();
+    let host = raw_args.host.clone();
+    let tag = raw_args.call_info.name_tag.clone();
+    let (EnterArgs { location, encoding }, _) = raw_args.process().await?;
+    let location_string = location.display().to_string();
+    let location_clone = location_string.clone();
+
+    if location_string.starts_with("help") {
+        let spec = location_string.split(':').collect::<Vec<&str>>();
+
+        if spec.len() == 2 {
+            let (_, command) = (spec[0], spec[1]);
+
+            if scope.has_command(command) {
+                return Ok(OutputStream::one(ReturnSuccess::action(
+                    CommandAction::EnterHelpShell(
+                        UntaggedValue::string(command).into_value(Tag::unknown()),
+                    ),
+                )));
+            }
+        }
+        Ok(OutputStream::one(ReturnSuccess::action(
+            CommandAction::EnterHelpShell(UntaggedValue::nothing().into_value(Tag::unknown())),
+        )))
+    } else if location.is_dir() {
+        Ok(OutputStream::one(ReturnSuccess::action(
+            CommandAction::EnterShell(location_clone),
+        )))
+    } else {
+        // If it's a file, attempt to open the file as a value and enter it
+        let cwd = shell_manager.path();
+
+        let full_path = std::path::PathBuf::from(cwd);
+        let span = location.span();
+
+        let (file_extension, tagged_contents) = crate::commands::open::fetch(
+            &full_path,
+            &PathBuf::from(location_clone),
+            span,
+            encoding,
+        )
+        .await?;
+
+        match tagged_contents.value {
+            UntaggedValue::Primitive(Primitive::String(_)) => {
+                if let Some(extension) = file_extension {
+                    let command_name = format!("from {}", extension);
+                    if let Some(converter) = scope.get_command(&command_name) {
+                        let new_args = RawCommandArgs {
+                            host,
+                            ctrl_c,
+                            current_errors,
+                            shell_manager,
+                            call_info: UnevaluatedCallInfo {
+                                args: nu_protocol::hir::Call {
+                                    head,
+                                    positional: None,
+                                    named: None,
+                                    span: Span::unknown(),
+                                    external_redirection: ExternalRedirection::Stdout,
+                                },
+                                name_tag: tag.clone(),
+                            },
+                            scope: scope.clone(),
+                        };
+                        let tag = tagged_contents.tag.clone();
+                        let mut result = converter
+                            .run(new_args.with_input(vec![tagged_contents]))
+                            .await?;
+                        let result_vec: Vec<Result<ReturnSuccess, ShellError>> =
+                            result.drain_vec().await;
+                        Ok(futures::stream::iter(result_vec.into_iter().map(
+                            move |res| match res {
+                                Ok(ReturnSuccess::Value(Value { value, .. })) => Ok(
+                                    ReturnSuccess::Action(CommandAction::EnterValueShell(Value {
+                                        value,
+                                        tag: tag.clone(),
+                                    })),
+                                ),
+                                x => x,
+                            },
+                        ))
+                        .to_output_stream())
+                    } else {
+                        Ok(OutputStream::one(ReturnSuccess::action(
+                            CommandAction::EnterValueShell(tagged_contents),
+                        )))
+                    }
+                } else {
+                    Ok(OutputStream::one(ReturnSuccess::action(
+                        CommandAction::EnterValueShell(tagged_contents),
+                    )))
+                }
+            }
+            _ => Ok(OutputStream::one(ReturnSuccess::action(
+                CommandAction::EnterValueShell(tagged_contents),
+            ))),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Enter;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Enter {})?)
+    }
+}

crates/nu-command/src/commands/every.rs

@@ -0,0 +1,98 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct Every;
+
+#[derive(Deserialize)]
+pub struct EveryArgs {
+    stride: Tagged<u64>,
+    skip: Tagged<bool>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Every {
+    fn name(&self) -> &str {
+        "every"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .required(
+                "stride",
+                SyntaxShape::Int,
+                "how many rows to skip between (and including) each row returned",
+            )
+            .switch(
+                "skip",
+                "skip the rows that would be returned, instead of selecting them",
+                Some('s'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Show (or skip) every n-th row, starting from the first one."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        every(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get every second row",
+                example: "echo [1 2 3 4 5] | every 2",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(3).into(),
+                    UntaggedValue::int(5).into(),
+                ]),
+            },
+            Example {
+                description: "Skip every second row",
+                example: "echo [1 2 3 4 5] | every 2 --skip",
+                result: Some(vec![
+                    UntaggedValue::int(2).into(),
+                    UntaggedValue::int(4).into(),
+                ]),
+            },
+        ]
+    }
+}
+
+async fn every(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (EveryArgs { stride, skip }, input) = args.process().await?;
+
+    let stride = stride.item;
+    let skip = skip.item;
+
+    Ok(input
+        .enumerate()
+        .filter_map(move |(i, value)| async move {
+            let stride_desired = if stride < 1 { 1 } else { stride } as usize;
+            let should_include = skip == (i % stride_desired != 0);
+
+            if should_include {
+                Some(ReturnSuccess::value(value))
+            } else {
+                None
+            }
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Every;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Every {})?)
+    }
+}

crates/nu-command/src/commands/exec.rs

@@ -0,0 +1,84 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape};
+use nu_source::Tagged;
+use std::path::PathBuf;
+
+pub struct Exec;
+
+#[derive(Deserialize)]
+pub struct ExecArgs {
+    pub command: Tagged<PathBuf>,
+    pub rest: Vec<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Exec {
+    fn name(&self) -> &str {
+        "exec"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("exec")
+            .required("command", SyntaxShape::FilePath, "the command to execute")
+            .rest(
+                SyntaxShape::GlobPattern,
+                "any additional arguments for command",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Execute command"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        exec(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Execute 'ps aux'",
+                example: "exec ps aux",
+                result: None,
+            },
+            Example {
+                description: "Execute 'nautilus'",
+                example: "exec nautilus",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(unix)]
+async fn exec(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    use std::os::unix::process::CommandExt;
+    use std::process::Command;
+
+    let name = args.call_info.name_tag.clone();
+    let (args, _): (ExecArgs, _) = args.process().await?;
+
+    let mut command = Command::new(args.command.item);
+    for tagged_arg in args.rest {
+        command.arg(tagged_arg.item);
+    }
+
+    let err = command.exec(); // this replaces our process, should not return
+
+    Err(ShellError::labeled_error(
+        "Error on exec",
+        format!("{}", err),
+        &name,
+    ))
+}
+
+#[cfg(not(unix))]
+async fn exec(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    Err(ShellError::labeled_error(
+        "Error on exec",
+        "exec is not supported on your platform",
+        &args.call_info.name_tag,
+    ))
+}

crates/nu-command/src/commands/exit.rs

@@ -0,0 +1,64 @@
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{CommandAction, ReturnSuccess, Signature};
+
+pub struct Exit;
+
+#[async_trait]
+impl WholeStreamCommand for Exit {
+    fn name(&self) -> &str {
+        "exit"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("exit").switch("now", "exit out of the shell immediately", Some('n'))
+    }
+
+    fn usage(&self) -> &str {
+        "Exit the current shell (or all shells)"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        exit(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Exit the current shell",
+                example: "exit",
+                result: None,
+            },
+            Example {
+                description: "Exit all shells (exiting Nu)",
+                example: "exit --now",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn exit(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+
+    let command_action = if args.call_info.args.has("now") {
+        CommandAction::Exit
+    } else {
+        CommandAction::LeaveShell
+    };
+
+    Ok(OutputStream::one(ReturnSuccess::action(command_action)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Exit;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Exit {})?)
+    }
+}

crates/nu-command/src/commands/first.rs

@@ -0,0 +1,77 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct First;
+
+#[derive(Deserialize)]
+pub struct FirstArgs {
+    rows: Option<Tagged<usize>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for First {
+    fn name(&self) -> &str {
+        "first"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("first").optional(
+            "rows",
+            SyntaxShape::Int,
+            "starting from the front, the number of rows to return",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Show only the first number of rows."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        first(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Return the first item of a list/table",
+                example: "echo [1 2 3] | first",
+                result: Some(vec![UntaggedValue::int(1).into()]),
+            },
+            Example {
+                description: "Return the first 2 items of a list/table",
+                example: "echo [1 2 3] | first 2",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(2).into(),
+                ]),
+            },
+        ]
+    }
+}
+
+async fn first(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (FirstArgs { rows }, input) = args.process().await?;
+    let rows_desired = if let Some(quantity) = rows {
+        *quantity
+    } else {
+        1
+    };
+
+    Ok(input.take(rows_desired).to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::First;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(First {})?)
+    }
+}

crates/nu-command/src/commands/flatten.rs

@@ -0,0 +1,183 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    Dictionary, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+
+pub struct Command;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    rest: Vec<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "flatten"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("flatten").rest(SyntaxShape::String, "optionally flatten data by column")
+    }
+
+    fn usage(&self) -> &str {
+        "Flatten the table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        flatten(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "flatten a table",
+                example: "echo [[N, u, s, h, e, l, l]] | flatten | first",
+                result: Some(vec![Value::from("N")]),
+            },
+            Example {
+                description: "flatten a column having a nested table",
+                example: "echo [[origin, people]; [Ecuador, $(echo [[name, meal]; ['Andres', 'arepa']])]] | flatten | get meal",
+                result: Some(vec![Value::from("arepa")]),
+            },
+            Example {
+                description: "restrict the flattening by passing column names",
+                example: "echo [[origin, crate, versions]; [World, $(echo [[name]; ['nu-cli']]), ['0.21', '0.22']]] | flatten versions | last | get versions",
+                result: Some(vec![Value::from("0.22")]),
+            }
+        ]
+    }
+}
+
+async fn flatten(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let (Arguments { rest: columns }, input) = args.process().await?;
+
+    Ok(input
+        .map(move |item| {
+            futures::stream::iter(flat_value(&columns, &item, &tag).into_iter().flatten())
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+enum TableInside<'a> {
+    Entries(&'a str, &'a Tag, Vec<&'a Value>),
+}
+
+fn flat_value(
+    columns: &[Tagged<String>],
+    item: &Value,
+    name_tag: impl Into<Tag>,
+) -> Result<Vec<Result<ReturnSuccess, ShellError>>, ShellError> {
+    let tag = item.tag.clone();
+    let name_tag = name_tag.into();
+
+    let res = {
+        if item.is_row() {
+            let mut out = TaggedDictBuilder::new(tag);
+            let mut a_table = None;
+            let mut tables_explicitly_flattened = 0;
+
+            for (column, value) in item.row_entries() {
+                let column_requested = columns.iter().find(|c| c.item == *column);
+
+                if let Value {
+                    value: UntaggedValue::Row(Dictionary { entries: mapa }),
+                    ..
+                } = value
+                {
+                    if column_requested.is_none() && !columns.is_empty() {
+                        if out.contains_key(&column) {
+                            out.insert_value(format!("{}_{}", column, column), value.clone());
+                        } else {
+                            out.insert_value(column, value.clone());
+                        }
+                        continue;
+                    }
+
+                    for (k, v) in mapa.into_iter() {
+                        if out.contains_key(k) {
+                            out.insert_value(format!("{}_{}", column, k), v.clone());
+                        } else {
+                            out.insert_value(k, v.clone());
+                        }
+                    }
+                } else if value.is_table() {
+                    if tables_explicitly_flattened >= 1 && column_requested.is_some() {
+                        let attempted = if let Some(name) = column_requested {
+                            name.span()
+                        } else {
+                            name_tag.span
+                        };
+
+                        let already_flattened =
+                            if let Some(TableInside::Entries(_, column_tag, _)) = a_table {
+                                column_tag.span
+                            } else {
+                                name_tag.span
+                            };
+
+                        return Ok(vec![ReturnSuccess::value(
+                            UntaggedValue::Error(ShellError::labeled_error_with_secondary(
+                                "can only flatten one inner table at the same time",
+                                "tried flattening more than one column with inner tables",
+                                attempted,
+                                "...but is flattened already",
+                                already_flattened,
+                            ))
+                            .into_value(name_tag),
+                        )]);
+                    }
+
+                    if !columns.is_empty() {
+                        if let Some(requested) = column_requested {
+                            a_table = Some(TableInside::Entries(
+                                &requested.item,
+                                &requested.tag,
+                                value.table_entries().collect(),
+                            ));
+
+                            tables_explicitly_flattened += 1;
+                        } else {
+                            out.insert_value(column, value.clone());
+                        }
+                    } else if a_table.is_none() {
+                        a_table = Some(TableInside::Entries(
+                            &column,
+                            &value.tag,
+                            value.table_entries().collect(),
+                        ))
+                    } else {
+                        out.insert_value(column, value.clone());
+                    }
+                } else {
+                    out.insert_value(column, value.clone());
+                }
+            }
+
+            let mut expanded = vec![];
+
+            if let Some(TableInside::Entries(column, _, entries)) = a_table {
+                for entry in entries.into_iter() {
+                    let mut base = out.clone();
+                    base.insert_value(column, entry.clone());
+                    expanded.push(base.into_value());
+                }
+            } else {
+                expanded.push(out.into_value());
+            }
+
+            expanded
+        } else if item.is_table() {
+            item.table_entries().map(Clone::clone).collect()
+        } else {
+            vec![item.clone()]
+        }
+    };
+
+    Ok(res.into_iter().map(ReturnSuccess::value).collect())
+}

crates/nu-command/src/commands/format/command.rs

@@ -0,0 +1,150 @@
+use crate::prelude::*;
+use nu_engine::evaluate_baseline_expr;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+use std::borrow::Borrow;
+
+pub struct Format;
+
+#[derive(Deserialize)]
+pub struct FormatArgs {
+    pattern: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Format {
+    fn name(&self) -> &str {
+        "format"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("format").required(
+            "pattern",
+            SyntaxShape::String,
+            "the pattern to output. Eg) \"{foo}: {bar}\"",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Format columns into a string using a simple pattern."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        format_command(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Print filenames with their sizes",
+            example: "ls | format '{name}: {size}'",
+            result: None,
+        }]
+    }
+}
+
+async fn format_command(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let ctx = Arc::new(EvaluationContext::from_args(&args));
+    let (FormatArgs { pattern }, input) = args.process().await?;
+
+    let format_pattern = format(&pattern);
+    let commands = Arc::new(format_pattern);
+
+    Ok(input
+        .then(move |value| {
+            let mut output = String::new();
+            let commands = commands.clone();
+            let ctx = ctx.clone();
+
+            async move {
+                for command in &*commands {
+                    match command {
+                        FormatCommand::Text(s) => {
+                            output.push_str(&s);
+                        }
+                        FormatCommand::Column(c) => {
+                            // FIXME: use the correct spans
+                            let full_column_path = nu_parser::parse_full_column_path(
+                                &(c.to_string()).spanned(Span::unknown()),
+                                &ctx.scope,
+                            );
+
+                            ctx.scope.enter_scope();
+                            ctx.scope.add_var("$it", value.clone());
+                            let result = evaluate_baseline_expr(&full_column_path.0, &*ctx).await;
+                            ctx.scope.exit_scope();
+
+                            if let Ok(c) = result {
+                                output
+                                    .push_str(&value::format_leaf(c.borrow()).plain_string(100_000))
+                            } else {
+                                // That column doesn't match, so don't emit anything
+                            }
+                        }
+                    }
+                }
+
+                ReturnSuccess::value(UntaggedValue::string(output).into_untagged_value())
+            }
+        })
+        .to_output_stream())
+}
+
+#[derive(Debug)]
+enum FormatCommand {
+    Text(String),
+    Column(String),
+}
+
+fn format(input: &str) -> Vec<FormatCommand> {
+    let mut output = vec![];
+
+    let mut loop_input = input.chars();
+    loop {
+        let mut before = String::new();
+
+        while let Some(c) = loop_input.next() {
+            if c == '{' {
+                break;
+            }
+            before.push(c);
+        }
+
+        if !before.is_empty() {
+            output.push(FormatCommand::Text(before.to_string()));
+        }
+        // Look for column as we're now at one
+        let mut column = String::new();
+
+        while let Some(c) = loop_input.next() {
+            if c == '}' {
+                break;
+            }
+            column.push(c);
+        }
+
+        if !column.is_empty() {
+            output.push(FormatCommand::Column(column.to_string()));
+        }
+
+        if before.is_empty() && column.is_empty() {
+            break;
+        }
+    }
+
+    output
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Format;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Format {})?)
+    }
+}

crates/nu-command/src/commands/format/format_filesize.rs

@@ -0,0 +1,186 @@
+use crate::prelude::*;
+use nu_errors::ShellError;
+
+use nu_engine::WholeStreamCommand;
+use nu_protocol::{
+    ColumnPath, Primitive::Filesize, ReturnSuccess, Signature, SyntaxShape, UntaggedValue,
+    UntaggedValue::Primitive, Value,
+};
+use nu_source::Tagged;
+use nu_value_ext::get_data_by_column_path;
+
+use num_format::{Locale, ToFormattedString};
+
+pub struct FileSize;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    field: ColumnPath,
+    format: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FileSize {
+    fn name(&self) -> &str {
+        "format filesize"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("format filesize")
+            .required(
+                "field",
+                SyntaxShape::ColumnPath,
+                "the name of the column to update",
+            )
+            .required(
+                "format value",
+                SyntaxShape::String,
+                "the format into which convert the filesizes",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Converts a column of filesizes to some specified format"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        filesize(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert the size row to KB",
+                example: "ls | format filesize size KB",
+                result: None,
+            },
+            Example {
+                description: "Convert the apparent row to B",
+                example: "du | format filesize apparent B",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn process_row(
+    input: Value,
+    format: Tagged<String>,
+    field: Arc<ColumnPath>,
+) -> Result<OutputStream, ShellError> {
+    Ok({
+        let replace_for = get_data_by_column_path(&input, &field, move |_, _, error| error);
+        match replace_for {
+            Ok(s) => match convert_bytes_to_string_using_format(s, format) {
+                Ok(b) => OutputStream::one(ReturnSuccess::value(
+                    input.replace_data_at_column_path(&field, b).expect("Given that the existence check was already done, this shouldn't trigger never"),
+                )),
+                Err(e) => OutputStream::one(Err(e)),
+            },
+            Err(e) => OutputStream::one(Err(e)),
+        }
+    })
+}
+
+async fn filesize(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (Arguments { field, format }, input) = raw_args.process().await?;
+    let field = Arc::new(field);
+
+    Ok(input
+        .then(move |input| {
+            let format = format.clone();
+            let field = field.clone();
+
+            async {
+                match process_row(input, format, field).await {
+                    Ok(s) => s,
+                    Err(e) => OutputStream::one(Err(e)),
+                }
+            }
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+fn convert_bytes_to_string_using_format(
+    bytes: Value,
+    format: Tagged<String>,
+) -> Result<Value, ShellError> {
+    match bytes.value {
+        Primitive(Filesize(b)) => {
+            let byte = byte_unit::Byte::from_bytes(b as u128);
+            let value = match format.item().to_lowercase().as_str() {
+                "b" => Ok(UntaggedValue::string(b.to_formatted_string(&Locale::en))),
+                "kb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::KB).to_string(),
+                )),
+                "kib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::KiB).to_string(),
+                )),
+                "mb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::MB).to_string(),
+                )),
+                "mib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::MiB).to_string(),
+                )),
+                "gb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::GB).to_string(),
+                )),
+                "gib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::GiB).to_string(),
+                )),
+                "tb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::TB).to_string(),
+                )),
+                "tib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::TiB).to_string(),
+                )),
+                "pb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::PB).to_string(),
+                )),
+                "pib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::PiB).to_string(),
+                )),
+                "eb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::EB).to_string(),
+                )),
+                "eib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::EiB).to_string(),
+                )),
+                "zb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::ZB).to_string(),
+                )),
+                "zib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::ZiB).to_string(),
+                )),
+                _ => Err(ShellError::labeled_error(
+                    format!("Invalid format code: {:}", format.item()),
+                    "invalid format",
+                    format.tag(),
+                )),
+            };
+            match value {
+                Ok(b) => Ok(Value { value: b, ..bytes }),
+                Err(e) => Err(e),
+            }
+        }
+        _ => Err(ShellError::labeled_error(
+            "the data in this row is not of the type filesize",
+            "invalid row type",
+            bytes.tag(),
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FileSize;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FileSize {})?)
+    }
+}

crates/nu-command/src/commands/format/mod.rs

@@ -0,0 +1,5 @@
+pub mod command;
+pub mod format_filesize;
+
+pub use command::Format;
+pub use format_filesize::FileSize;

crates/nu-command/src/commands/from.rs

@@ -0,0 +1,40 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct From;
+
+#[async_trait]
+impl WholeStreamCommand for From {
+    fn name(&self) -> &str {
+        "from"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse content (string or binary) as a table (input format based on subcommand, like csv, ini, json, toml)"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(get_help(&From, &args.scope)).into_value(Tag::unknown()),
+        )))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::From;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(From {})?)
+    }
+}

crates/nu-command/src/commands/from_csv.rs

@@ -0,0 +1,112 @@
+use crate::commands::from_delimited_data::from_delimited_data;
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct FromCSV;
+
+#[derive(Deserialize)]
+pub struct FromCSVArgs {
+    headerless: bool,
+    separator: Option<Value>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FromCSV {
+    fn name(&self) -> &str {
+        "from csv"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from csv")
+            .named(
+                "separator",
+                SyntaxShape::String,
+                "a character to separate columns, defaults to ','",
+                Some('s'),
+            )
+            .switch(
+                "headerless",
+                "don't treat the first row as column names",
+                None,
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .csv and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_csv(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert comma-separated data to a table",
+                example: "open data.txt | from csv",
+                result: None,
+            },
+            Example {
+                description: "Convert comma-separated data to a table, ignoring headers",
+                example: "open data.txt | from csv --headerless",
+                result: None,
+            },
+            Example {
+                description: "Convert semicolon-separated data to a table",
+                example: "open data.txt | from csv --separator ';'",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn from_csv(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+
+    let (
+        FromCSVArgs {
+            headerless,
+            separator,
+        },
+        input,
+    ) = args.process().await?;
+    let sep = match separator {
+        Some(Value {
+            value: UntaggedValue::Primitive(Primitive::String(s)),
+            tag,
+            ..
+        }) => {
+            if s == r"\t" {
+                '\t'
+            } else {
+                let vec_s: Vec<char> = s.chars().collect();
+                if vec_s.len() != 1 {
+                    return Err(ShellError::labeled_error(
+                        "Expected a single separator char from --separator",
+                        "requires a single character string input",
+                        tag,
+                    ));
+                };
+                vec_s[0]
+            }
+        }
+        _ => ',',
+    };
+
+    from_delimited_data(headerless, sep, "CSV", input, name).await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromCSV;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromCSV {})?)
+    }
+}

crates/nu-command/src/commands/from_delimited_data.rs

@@ -0,0 +1,112 @@
+use crate::prelude::*;
+use csv::{ErrorKind, ReaderBuilder};
+use nu_errors::ShellError;
+use nu_protocol::{TaggedDictBuilder, UntaggedValue, Value};
+
+fn from_delimited_string_to_value(
+    s: String,
+    headerless: bool,
+    separator: char,
+    tag: impl Into<Tag>,
+) -> Result<Value, csv::Error> {
+    let mut reader = ReaderBuilder::new()
+        .has_headers(!headerless)
+        .delimiter(separator as u8)
+        .from_reader(s.as_bytes());
+    let tag = tag.into();
+    let span = tag.span;
+
+    let headers = if headerless {
+        (1..=reader.headers()?.len())
+            .map(|i| format!("Column{}", i))
+            .collect::<Vec<String>>()
+    } else {
+        reader.headers()?.iter().map(String::from).collect()
+    };
+
+    let mut rows = vec![];
+    for row in reader.records() {
+        let mut tagged_row = TaggedDictBuilder::new(&tag);
+        for (value, header) in row?.iter().zip(headers.iter()) {
+            if let Ok(i) = value.parse::<i64>() {
+                tagged_row.insert_value(header, UntaggedValue::int(i).into_value(&tag))
+            } else if let Ok(f) = value.parse::<f64>() {
+                tagged_row.insert_value(
+                    header,
+                    UntaggedValue::decimal_from_float(f, span).into_value(&tag),
+                )
+            } else {
+                tagged_row.insert_value(header, UntaggedValue::string(value).into_value(&tag))
+            }
+        }
+        rows.push(tagged_row.into_value());
+    }
+
+    Ok(UntaggedValue::Table(rows).into_value(&tag))
+}
+
+pub async fn from_delimited_data(
+    headerless: bool,
+    sep: char,
+    format_name: &'static str,
+    input: InputStream,
+    name: Tag,
+) -> Result<OutputStream, ShellError> {
+    let name_tag = name;
+    let concat_string = input.collect_string(name_tag.clone()).await?;
+    let sample_lines = concat_string.item.lines().take(3).collect_vec().join("\n");
+
+    match from_delimited_string_to_value(concat_string.item, headerless, sep, name_tag.clone()) {
+        Ok(x) => match x {
+            Value {
+                value: UntaggedValue::Table(list),
+                ..
+            } => Ok(futures::stream::iter(list).to_output_stream()),
+            x => Ok(OutputStream::one(x)),
+        },
+        Err(err) => {
+            let line_one = match pretty_csv_error(err) {
+                Some(pretty) => format!(
+                    "Could not parse as {} split by '{}' ({})",
+                    format_name, sep, pretty
+                ),
+                None => format!("Could not parse as {} split by '{}'", format_name, sep),
+            };
+            let line_two = format!(
+                "input cannot be parsed as {} split by '{}'. Input's first lines:\n{}",
+                format_name, sep, sample_lines
+            );
+
+            Err(ShellError::labeled_error_with_secondary(
+                line_one,
+                line_two,
+                name_tag.clone(),
+                "value originates from here",
+                concat_string.tag,
+            ))
+        }
+    }
+}
+
+fn pretty_csv_error(err: csv::Error) -> Option<String> {
+    match err.kind() {
+        ErrorKind::UnequalLengths {
+            pos,
+            expected_len,
+            len,
+        } => {
+            if let Some(pos) = pos {
+                Some(format!(
+                    "Line {}: expected {} fields, found {}",
+                    pos.line(),
+                    expected_len,
+                    len
+                ))
+            } else {
+                Some(format!("Expected {} fields, found {}", expected_len, len))
+            }
+        }
+        ErrorKind::Seek => Some("Internal error while parsing csv".to_string()),
+        _ => None,
+    }
+}

crates/nu-command/src/commands/from_eml.rs

@@ -0,0 +1,133 @@
+use crate::prelude::*;
+use ::eml_parser::eml::*;
+use ::eml_parser::EmlParser;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct FromEML;
+
+const DEFAULT_BODY_PREVIEW: usize = 50;
+
+#[derive(Deserialize, Clone)]
+pub struct FromEMLArgs {
+    #[serde(rename(deserialize = "preview-body"))]
+    preview_body: Option<Tagged<usize>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FromEML {
+    fn name(&self) -> &str {
+        "from eml"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from eml").named(
+            "preview-body",
+            SyntaxShape::Int,
+            "How many bytes of the body to preview",
+            Some('b'),
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .eml and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_eml(args).await
+    }
+}
+
+fn emailaddress_to_value(tag: &Tag, email_address: &EmailAddress) -> TaggedDictBuilder {
+    let mut dict = TaggedDictBuilder::with_capacity(tag, 2);
+    let (n, a) = match email_address {
+        EmailAddress::AddressOnly { address } => {
+            (UntaggedValue::nothing(), UntaggedValue::string(address))
+        }
+        EmailAddress::NameAndEmailAddress { name, address } => {
+            (UntaggedValue::string(name), UntaggedValue::string(address))
+        }
+    };
+
+    dict.insert_untagged("Name", n);
+    dict.insert_untagged("Address", a);
+
+    dict
+}
+
+fn headerfieldvalue_to_value(tag: &Tag, value: &HeaderFieldValue) -> UntaggedValue {
+    use HeaderFieldValue::*;
+
+    match value {
+        SingleEmailAddress(address) => emailaddress_to_value(tag, address).into_untagged_value(),
+        MultipleEmailAddresses(addresses) => UntaggedValue::Table(
+            addresses
+                .iter()
+                .map(|a| emailaddress_to_value(tag, a).into_value())
+                .collect(),
+        ),
+        Unstructured(s) => UntaggedValue::string(s),
+        Empty => UntaggedValue::nothing(),
+    }
+}
+
+async fn from_eml(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let (eml_args, input): (FromEMLArgs, _) = args.process().await?;
+    let value = input.collect_string(tag.clone()).await?;
+
+    let body_preview = eml_args
+        .preview_body
+        .map(|b| b.item)
+        .unwrap_or(DEFAULT_BODY_PREVIEW);
+
+    let eml = EmlParser::from_string(value.item)
+        .with_body_preview(body_preview)
+        .parse()
+        .map_err(|_| {
+            ShellError::labeled_error(
+                "Could not parse .eml file",
+                "could not parse .eml file",
+                &tag,
+            )
+        })?;
+
+    let mut dict = TaggedDictBuilder::new(&tag);
+
+    if let Some(subj) = eml.subject {
+        dict.insert_untagged("Subject", UntaggedValue::string(subj));
+    }
+
+    if let Some(from) = eml.from {
+        dict.insert_untagged("From", headerfieldvalue_to_value(&tag, &from));
+    }
+
+    if let Some(to) = eml.to {
+        dict.insert_untagged("To", headerfieldvalue_to_value(&tag, &to));
+    }
+
+    for HeaderField { name, value } in eml.headers.iter() {
+        dict.insert_untagged(name, headerfieldvalue_to_value(&tag, &value));
+    }
+
+    if let Some(body) = eml.body {
+        dict.insert_untagged("Body", UntaggedValue::string(body));
+    }
+
+    Ok(OutputStream::one(ReturnSuccess::value(dict.into_value())))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromEML;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromEML {})?)
+    }
+}

crates/nu-command/src/commands/from_ics.rs

@@ -0,0 +1,252 @@
+extern crate ical;
+use crate::prelude::*;
+use ical::parser::ical::component::*;
+use ical::property::Property;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
+use std::io::BufReader;
+
+pub struct FromIcs;
+
+#[async_trait]
+impl WholeStreamCommand for FromIcs {
+    fn name(&self) -> &str {
+        "from ics"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from ics")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .ics and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_ics(args).await
+    }
+}
+
+async fn from_ics(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.name_tag();
+    let input = args.input;
+
+    let input_string = input.collect_string(tag.clone()).await?.item;
+    let input_bytes = input_string.as_bytes();
+    let buf_reader = BufReader::new(input_bytes);
+    let parser = ical::IcalParser::new(buf_reader);
+
+    // TODO: it should be possible to make this a stream, but the some of the lifetime requirements make this tricky.
+    // Pre-computing for now
+    let mut output = vec![];
+
+    for calendar in parser {
+        match calendar {
+            Ok(c) => output.push(ReturnSuccess::value(calendar_to_value(c, tag.clone()))),
+            Err(_) => output.push(Err(ShellError::labeled_error(
+                "Could not parse as .ics",
+                "input cannot be parsed as .ics",
+                tag.clone(),
+            ))),
+        }
+    }
+
+    Ok(futures::stream::iter(output).to_output_stream())
+}
+
+fn calendar_to_value(calendar: IcalCalendar, tag: Tag) -> Value {
+    let mut row = TaggedDictBuilder::new(tag.clone());
+
+    row.insert_untagged(
+        "properties",
+        properties_to_value(calendar.properties, tag.clone()),
+    );
+    row.insert_untagged("events", events_to_value(calendar.events, tag.clone()));
+    row.insert_untagged("alarms", alarms_to_value(calendar.alarms, tag.clone()));
+    row.insert_untagged("to-Dos", todos_to_value(calendar.todos, tag.clone()));
+    row.insert_untagged(
+        "journals",
+        journals_to_value(calendar.journals, tag.clone()),
+    );
+    row.insert_untagged(
+        "free-busys",
+        free_busys_to_value(calendar.free_busys, tag.clone()),
+    );
+    row.insert_untagged("timezones", timezones_to_value(calendar.timezones, tag));
+
+    row.into_value()
+}
+
+fn events_to_value(events: Vec<IcalEvent>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &events
+            .into_iter()
+            .map(|event| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(event.properties, tag.clone()),
+                );
+                row.insert_untagged("alarms", alarms_to_value(event.alarms, tag.clone()));
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn alarms_to_value(alarms: Vec<IcalAlarm>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &alarms
+            .into_iter()
+            .map(|alarm| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(alarm.properties, tag.clone()),
+                );
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn todos_to_value(todos: Vec<IcalTodo>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &todos
+            .into_iter()
+            .map(|todo| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(todo.properties, tag.clone()),
+                );
+                row.insert_untagged("alarms", alarms_to_value(todo.alarms, tag.clone()));
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn journals_to_value(journals: Vec<IcalJournal>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &journals
+            .into_iter()
+            .map(|journal| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(journal.properties, tag.clone()),
+                );
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn free_busys_to_value(free_busys: Vec<IcalFreeBusy>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &free_busys
+            .into_iter()
+            .map(|free_busy| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(free_busy.properties, tag.clone()),
+                );
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn timezones_to_value(timezones: Vec<IcalTimeZone>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &timezones
+            .into_iter()
+            .map(|timezone| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(timezone.properties, tag.clone()),
+                );
+                row.insert_untagged(
+                    "transitions",
+                    timezone_transitions_to_value(timezone.transitions, tag.clone()),
+                );
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn timezone_transitions_to_value(
+    transitions: Vec<IcalTimeZoneTransition>,
+    tag: Tag,
+) -> UntaggedValue {
+    UntaggedValue::table(
+        &transitions
+            .into_iter()
+            .map(|transition| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(transition.properties, tag.clone()),
+                );
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn properties_to_value(properties: Vec<Property>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &properties
+            .into_iter()
+            .map(|prop| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+
+                let name = UntaggedValue::string(prop.name);
+                let value = match prop.value {
+                    Some(val) => UntaggedValue::string(val),
+                    None => UntaggedValue::Primitive(Primitive::Nothing),
+                };
+                let params = match prop.params {
+                    Some(param_list) => params_to_value(param_list, tag.clone()).into(),
+                    None => UntaggedValue::Primitive(Primitive::Nothing),
+                };
+
+                row.insert_untagged("name", name);
+                row.insert_untagged("value", value);
+                row.insert_untagged("params", params);
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn params_to_value(params: Vec<(String, Vec<String>)>, tag: Tag) -> Value {
+    let mut row = TaggedDictBuilder::new(tag);
+
+    for (param_name, param_values) in params {
+        let values: Vec<Value> = param_values.into_iter().map(|val| val.into()).collect();
+        let values = UntaggedValue::table(&values);
+        row.insert_untagged(param_name, values);
+    }
+
+    row.into_value()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromIcs;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromIcs {})?)
+    }
+}

crates/nu-command/src/commands/from_ini.rs

@@ -0,0 +1,98 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, Signature, TaggedDictBuilder, UntaggedValue, Value};
+use std::collections::HashMap;
+
+pub struct FromINI;
+
+#[async_trait]
+impl WholeStreamCommand for FromINI {
+    fn name(&self) -> &str {
+        "from ini"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from ini")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .ini and create table"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_ini(args).await
+    }
+}
+
+fn convert_ini_second_to_nu_value(v: &HashMap<String, String>, tag: impl Into<Tag>) -> Value {
+    let mut second = TaggedDictBuilder::new(tag);
+
+    for (key, value) in v.iter() {
+        second.insert_untagged(key.clone(), Primitive::String(value.clone()));
+    }
+
+    second.into_value()
+}
+
+fn convert_ini_top_to_nu_value(
+    v: &HashMap<String, HashMap<String, String>>,
+    tag: impl Into<Tag>,
+) -> Value {
+    let tag = tag.into();
+    let mut top_level = TaggedDictBuilder::new(tag.clone());
+
+    for (key, value) in v.iter() {
+        top_level.insert_value(
+            key.clone(),
+            convert_ini_second_to_nu_value(value, tag.clone()),
+        );
+    }
+
+    top_level.into_value()
+}
+
+pub fn from_ini_string_to_value(
+    s: String,
+    tag: impl Into<Tag>,
+) -> Result<Value, serde_ini::de::Error> {
+    let v: HashMap<String, HashMap<String, String>> = serde_ini::from_str(&s)?;
+    Ok(convert_ini_top_to_nu_value(&v, tag))
+}
+
+async fn from_ini(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.name_tag();
+    let input = args.input;
+    let concat_string = input.collect_string(tag.clone()).await?;
+
+    match from_ini_string_to_value(concat_string.item, tag.clone()) {
+        Ok(x) => match x {
+            Value {
+                value: UntaggedValue::Table(list),
+                ..
+            } => Ok(futures::stream::iter(list).to_output_stream()),
+            x => Ok(OutputStream::one(x)),
+        },
+        Err(_) => Err(ShellError::labeled_error_with_secondary(
+            "Could not parse as INI",
+            "input cannot be parsed as INI",
+            &tag,
+            "value originates from here",
+            concat_string.tag,
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromINI;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromINI {})?)
+    }
+}

crates/nu-command/src/commands/from_json.rs

@@ -0,0 +1,147 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
+
+pub struct FromJSON;
+
+#[derive(Deserialize)]
+pub struct FromJSONArgs {
+    objects: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FromJSON {
+    fn name(&self) -> &str {
+        "from json"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from json").switch(
+            "objects",
+            "treat each line as a separate value",
+            Some('o'),
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .json and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_json(args).await
+    }
+}
+
+fn convert_json_value_to_nu_value(v: &nu_json::Value, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+    let span = tag.span;
+
+    match v {
+        nu_json::Value::Null => UntaggedValue::Primitive(Primitive::Nothing).into_value(&tag),
+        nu_json::Value::Bool(b) => UntaggedValue::boolean(*b).into_value(&tag),
+        nu_json::Value::F64(n) => UntaggedValue::decimal_from_float(*n, span).into_value(&tag),
+        nu_json::Value::U64(n) => UntaggedValue::int(*n).into_value(&tag),
+        nu_json::Value::I64(n) => UntaggedValue::int(*n).into_value(&tag),
+        nu_json::Value::String(s) => {
+            UntaggedValue::Primitive(Primitive::String(String::from(s))).into_value(&tag)
+        }
+        nu_json::Value::Array(a) => UntaggedValue::Table(
+            a.iter()
+                .map(|x| convert_json_value_to_nu_value(x, &tag))
+                .collect(),
+        )
+        .into_value(tag),
+        nu_json::Value::Object(o) => {
+            let mut collected = TaggedDictBuilder::new(&tag);
+            for (k, v) in o.iter() {
+                collected.insert_value(k.clone(), convert_json_value_to_nu_value(v, &tag));
+            }
+
+            collected.into_value()
+        }
+    }
+}
+
+pub fn from_json_string_to_value(s: String, tag: impl Into<Tag>) -> nu_json::Result<Value> {
+    let v: nu_json::Value = nu_json::from_str(&s)?;
+    Ok(convert_json_value_to_nu_value(&v, tag))
+}
+
+async fn from_json(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_tag = args.call_info.name_tag.clone();
+
+    let (FromJSONArgs { objects }, input) = args.process().await?;
+    let concat_string = input.collect_string(name_tag.clone()).await?;
+
+    let string_clone: Vec<_> = concat_string.item.lines().map(|x| x.to_string()).collect();
+
+    if objects {
+        Ok(
+            futures::stream::iter(string_clone.into_iter().filter_map(move |json_str| {
+                if json_str.is_empty() {
+                    return None;
+                }
+
+                match from_json_string_to_value(json_str, &name_tag) {
+                    Ok(x) => Some(ReturnSuccess::value(x)),
+                    Err(e) => {
+                        let mut message = "Could not parse as JSON (".to_string();
+                        message.push_str(&e.to_string());
+                        message.push(')');
+
+                        Some(Err(ShellError::labeled_error_with_secondary(
+                            message,
+                            "input cannot be parsed as JSON",
+                            name_tag.clone(),
+                            "value originates from here",
+                            concat_string.tag.clone(),
+                        )))
+                    }
+                }
+            }))
+            .to_output_stream(),
+        )
+    } else {
+        match from_json_string_to_value(concat_string.item, name_tag.clone()) {
+            Ok(x) => match x {
+                Value {
+                    value: UntaggedValue::Table(list),
+                    ..
+                } => Ok(
+                    futures::stream::iter(list.into_iter().map(ReturnSuccess::value))
+                        .to_output_stream(),
+                ),
+                x => Ok(OutputStream::one(ReturnSuccess::value(x))),
+            },
+            Err(e) => {
+                let mut message = "Could not parse as JSON (".to_string();
+                message.push_str(&e.to_string());
+                message.push(')');
+
+                Ok(OutputStream::one(Err(
+                    ShellError::labeled_error_with_secondary(
+                        message,
+                        "input cannot be parsed as JSON",
+                        name_tag,
+                        "value originates from here",
+                        concat_string.tag,
+                    ),
+                )))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromJSON;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromJSON {})?)
+    }
+}

crates/nu-command/src/commands/from_ods.rs

@@ -0,0 +1,105 @@
+use crate::prelude::*;
+use calamine::*;
+use nu_data::TaggedListBuilder;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue};
+use std::io::Cursor;
+
+pub struct FromODS;
+
+#[derive(Deserialize)]
+pub struct FromODSArgs {
+    headerless: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FromODS {
+    fn name(&self) -> &str {
+        "from ods"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from ods").switch(
+            "headerless",
+            "don't treat the first row as column names",
+            None,
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Parse OpenDocument Spreadsheet(.ods) data and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_ods(args).await
+    }
+}
+
+async fn from_ods(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let span = tag.span;
+
+    let (
+        FromODSArgs {
+            headerless: _headerless,
+        },
+        input,
+    ) = args.process().await?;
+    let bytes = input.collect_binary(tag.clone()).await?;
+    let buf: Cursor<Vec<u8>> = Cursor::new(bytes.item);
+    let mut ods = Ods::<_>::new(buf).map_err(|_| {
+        ShellError::labeled_error("Could not load ods file", "could not load ods file", &tag)
+    })?;
+
+    let mut dict = TaggedDictBuilder::new(&tag);
+
+    let sheet_names = ods.sheet_names().to_owned();
+
+    for sheet_name in &sheet_names {
+        let mut sheet_output = TaggedListBuilder::new(&tag);
+
+        if let Some(Ok(current_sheet)) = ods.worksheet_range(sheet_name) {
+            for row in current_sheet.rows() {
+                let mut row_output = TaggedDictBuilder::new(&tag);
+                for (i, cell) in row.iter().enumerate() {
+                    let value = match cell {
+                        DataType::Empty => UntaggedValue::nothing(),
+                        DataType::String(s) => UntaggedValue::string(s),
+                        DataType::Float(f) => UntaggedValue::decimal_from_float(*f, span),
+                        DataType::Int(i) => UntaggedValue::int(*i),
+                        DataType::Bool(b) => UntaggedValue::boolean(*b),
+                        _ => UntaggedValue::nothing(),
+                    };
+
+                    row_output.insert_untagged(&format!("Column{}", i), value);
+                }
+
+                sheet_output.push_untagged(row_output.into_untagged_value());
+            }
+
+            dict.insert_untagged(sheet_name, sheet_output.into_untagged_value());
+        } else {
+            return Err(ShellError::labeled_error(
+                "Could not load sheet",
+                "could not load sheet",
+                &tag,
+            ));
+        }
+    }
+
+    Ok(OutputStream::one(ReturnSuccess::value(dict.into_value())))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromODS;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromODS {})?)
+    }
+}

crates/nu-command/src/commands/from_ssv.rs

@@ -0,0 +1,507 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    Primitive, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+
+pub struct FromSSV;
+
+#[derive(Deserialize)]
+pub struct FromSSVArgs {
+    headerless: bool,
+    #[serde(rename(deserialize = "aligned-columns"))]
+    aligned_columns: bool,
+    #[serde(rename(deserialize = "minimum-spaces"))]
+    minimum_spaces: Option<Tagged<usize>>,
+}
+
+const STRING_REPRESENTATION: &str = "from ssv";
+const DEFAULT_MINIMUM_SPACES: usize = 2;
+
+#[async_trait]
+impl WholeStreamCommand for FromSSV {
+    fn name(&self) -> &str {
+        STRING_REPRESENTATION
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(STRING_REPRESENTATION)
+            .switch(
+                "headerless",
+                "don't treat the first row as column names",
+                None,
+            )
+            .switch("aligned-columns", "assume columns are aligned", Some('a'))
+            .named(
+                "minimum-spaces",
+                SyntaxShape::Int,
+                "the minimum spaces to separate columns",
+                Some('m'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as space-separated values and create a table. The default minimum number of spaces counted as a separator is 2."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_ssv(args).await
+    }
+}
+
+enum HeaderOptions<'a> {
+    WithHeaders(&'a str),
+    WithoutHeaders,
+}
+
+fn parse_aligned_columns<'a>(
+    lines: impl Iterator<Item = &'a str>,
+    headers: HeaderOptions,
+    separator: &str,
+) -> Vec<Vec<(String, String)>> {
+    fn construct<'a>(
+        lines: impl Iterator<Item = &'a str>,
+        headers: Vec<(String, usize)>,
+    ) -> Vec<Vec<(String, String)>> {
+        lines
+            .map(|l| {
+                headers
+                    .iter()
+                    .enumerate()
+                    .map(|(i, (header_name, start_position))| {
+                        let val = match headers.get(i + 1) {
+                            Some((_, end)) => {
+                                if *end < l.len() {
+                                    l.get(*start_position..*end)
+                                } else {
+                                    l.get(*start_position..)
+                                }
+                            }
+                            None => l.get(*start_position..),
+                        }
+                        .unwrap_or("")
+                        .trim()
+                        .into();
+                        (header_name.clone(), val)
+                    })
+                    .collect()
+            })
+            .collect()
+    }
+
+    let find_indices = |line: &str| {
+        let values = line
+            .split(&separator)
+            .map(str::trim)
+            .filter(|s| !s.is_empty());
+        values
+            .fold(
+                (0, vec![]),
+                |(current_pos, mut indices), value| match line[current_pos..].find(value) {
+                    None => (current_pos, indices),
+                    Some(index) => {
+                        let absolute_index = current_pos + index;
+                        indices.push(absolute_index);
+                        (absolute_index + value.len(), indices)
+                    }
+                },
+            )
+            .1
+    };
+
+    let parse_with_headers = |lines, headers_raw: &str| {
+        let indices = find_indices(headers_raw);
+        let headers = headers_raw
+            .split(&separator)
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
+            .map(String::from)
+            .zip(indices);
+
+        let columns = headers.collect::<Vec<(String, usize)>>();
+
+        construct(lines, columns)
+    };
+
+    let parse_without_headers = |ls: Vec<&str>| {
+        let mut indices = ls
+            .iter()
+            .flat_map(|s| find_indices(*s))
+            .collect::<Vec<usize>>();
+
+        indices.sort_unstable();
+        indices.dedup();
+
+        let headers: Vec<(String, usize)> = indices
+            .iter()
+            .enumerate()
+            .map(|(i, position)| (format!("Column{}", i + 1), *position))
+            .collect();
+
+        construct(ls.iter().map(|s| s.to_owned()), headers)
+    };
+
+    match headers {
+        HeaderOptions::WithHeaders(headers_raw) => parse_with_headers(lines, headers_raw),
+        HeaderOptions::WithoutHeaders => parse_without_headers(lines.collect()),
+    }
+}
+
+fn parse_separated_columns<'a>(
+    lines: impl Iterator<Item = &'a str>,
+    headers: HeaderOptions,
+    separator: &str,
+) -> Vec<Vec<(String, String)>> {
+    fn collect<'a>(
+        headers: Vec<String>,
+        rows: impl Iterator<Item = &'a str>,
+        separator: &str,
+    ) -> Vec<Vec<(String, String)>> {
+        rows.map(|r| {
+            headers
+                .iter()
+                .zip(r.split(separator).map(str::trim).filter(|s| !s.is_empty()))
+                .map(|(a, b)| (a.to_owned(), b.to_owned()))
+                .collect()
+        })
+        .collect()
+    }
+
+    let parse_with_headers = |lines, headers_raw: &str| {
+        let headers = headers_raw
+            .split(&separator)
+            .map(str::trim)
+            .map(str::to_owned)
+            .filter(|s| !s.is_empty())
+            .collect();
+        collect(headers, lines, separator)
+    };
+
+    let parse_without_headers = |ls: Vec<&str>| {
+        let num_columns = ls.iter().map(|r| r.len()).max().unwrap_or(0);
+
+        let headers = (1..=num_columns)
+            .map(|i| format!("Column{}", i))
+            .collect::<Vec<String>>();
+        collect(headers, ls.into_iter(), separator)
+    };
+
+    match headers {
+        HeaderOptions::WithHeaders(headers_raw) => parse_with_headers(lines, headers_raw),
+        HeaderOptions::WithoutHeaders => parse_without_headers(lines.collect()),
+    }
+}
+
+fn string_to_table(
+    s: &str,
+    headerless: bool,
+    aligned_columns: bool,
+    split_at: usize,
+) -> Vec<Vec<(String, String)>> {
+    let mut lines = s.lines().filter(|l| !l.trim().is_empty());
+    let separator = " ".repeat(std::cmp::max(split_at, 1));
+
+    let (ls, header_options) = if headerless {
+        (lines, HeaderOptions::WithoutHeaders)
+    } else {
+        match lines.next() {
+            Some(header) => (lines, HeaderOptions::WithHeaders(header)),
+            None => return vec![],
+        }
+    };
+
+    let f = if aligned_columns {
+        parse_aligned_columns
+    } else {
+        parse_separated_columns
+    };
+
+    f(ls, header_options, &separator)
+}
+
+fn from_ssv_string_to_value(
+    s: &str,
+    headerless: bool,
+    aligned_columns: bool,
+    split_at: usize,
+    tag: impl Into<Tag>,
+) -> Option<Value> {
+    let tag = tag.into();
+    let rows = string_to_table(s, headerless, aligned_columns, split_at)
+        .iter()
+        .map(|row| {
+            let mut tagged_dict = TaggedDictBuilder::new(&tag);
+            for (col, entry) in row {
+                tagged_dict.insert_value(
+                    col,
+                    UntaggedValue::Primitive(Primitive::String(String::from(entry)))
+                        .into_value(&tag),
+                )
+            }
+            tagged_dict.into_value()
+        })
+        .collect();
+
+    Some(UntaggedValue::Table(rows).into_value(&tag))
+}
+
+async fn from_ssv(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let (
+        FromSSVArgs {
+            headerless,
+            aligned_columns,
+            minimum_spaces,
+        },
+        input,
+    ) = args.process().await?;
+    let concat_string = input.collect_string(name.clone()).await?;
+    let split_at = match minimum_spaces {
+        Some(number) => number.item,
+        None => DEFAULT_MINIMUM_SPACES,
+    };
+
+    Ok(
+        match from_ssv_string_to_value(
+            &concat_string.item,
+            headerless,
+            aligned_columns,
+            split_at,
+            name.clone(),
+        ) {
+            Some(x) => match x {
+                Value {
+                    value: UntaggedValue::Table(list),
+                    ..
+                } => futures::stream::iter(list.into_iter().map(ReturnSuccess::value))
+                    .to_output_stream(),
+                x => OutputStream::one(ReturnSuccess::value(x)),
+            },
+            None => {
+                return Err(ShellError::labeled_error_with_secondary(
+                    "Could not parse as SSV",
+                    "input cannot be parsed ssv",
+                    &name,
+                    "value originates from here",
+                    &concat_string.tag,
+                ));
+            }
+        },
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::*;
+
+    fn owned(x: &str, y: &str) -> (String, String) {
+        (String::from(x), String::from(y))
+    }
+
+    #[test]
+    fn it_trims_empty_and_whitespace_only_lines() {
+        let input = r#"
+
+            a       b
+
+            1       2
+
+            3       4
+        "#;
+        let result = string_to_table(input, false, true, 1);
+        assert_eq!(
+            result,
+            vec![
+                vec![owned("a", "1"), owned("b", "2")],
+                vec![owned("a", "3"), owned("b", "4")]
+            ]
+        );
+    }
+
+    #[test]
+    fn it_deals_with_single_column_input() {
+        let input = r#"
+            a
+            1
+            2
+        "#;
+        let result = string_to_table(input, false, true, 1);
+        assert_eq!(result, vec![vec![owned("a", "1")], vec![owned("a", "2")]]);
+    }
+
+    #[test]
+    fn it_uses_first_row_as_data_when_headerless() {
+        let input = r#"
+            a b
+            1 2
+            3 4
+        "#;
+        let result = string_to_table(input, true, true, 1);
+        assert_eq!(
+            result,
+            vec![
+                vec![owned("Column1", "a"), owned("Column2", "b")],
+                vec![owned("Column1", "1"), owned("Column2", "2")],
+                vec![owned("Column1", "3"), owned("Column2", "4")]
+            ]
+        );
+    }
+
+    #[test]
+    fn it_allows_a_predefined_number_of_spaces() {
+        let input = r#"
+            column a   column b
+            entry 1    entry number  2
+            3          four
+        "#;
+
+        let result = string_to_table(input, false, true, 3);
+        assert_eq!(
+            result,
+            vec![
+                vec![
+                    owned("column a", "entry 1"),
+                    owned("column b", "entry number  2")
+                ],
+                vec![owned("column a", "3"), owned("column b", "four")]
+            ]
+        );
+    }
+
+    #[test]
+    fn it_trims_remaining_separator_space() {
+        let input = r#"
+            colA   colB     colC
+            val1   val2     val3
+        "#;
+
+        let trimmed = |s: &str| s.trim() == s;
+
+        let result = string_to_table(input, false, true, 2);
+        assert!(result
+            .iter()
+            .all(|row| row.iter().all(|(a, b)| trimmed(a) && trimmed(b))));
+    }
+
+    #[test]
+    fn it_keeps_empty_columns() {
+        let input = r#"
+            colA   col B     col C
+                   val2      val3
+            val4   val 5     val 6
+            val7             val8
+        "#;
+
+        let result = string_to_table(input, false, true, 2);
+        assert_eq!(
+            result,
+            vec![
+                vec![
+                    owned("colA", ""),
+                    owned("col B", "val2"),
+                    owned("col C", "val3")
+                ],
+                vec![
+                    owned("colA", "val4"),
+                    owned("col B", "val 5"),
+                    owned("col C", "val 6")
+                ],
+                vec![
+                    owned("colA", "val7"),
+                    owned("col B", ""),
+                    owned("col C", "val8")
+                ],
+            ]
+        );
+    }
+
+    #[test]
+    fn it_can_produce_an_empty_stream_for_header_only_input() {
+        let input = "colA   col B";
+
+        let result = string_to_table(input, false, true, 2);
+        let expected: Vec<Vec<(String, String)>> = vec![];
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn it_uses_the_full_final_column() {
+        let input = r#"
+            colA   col B
+            val1   val2   trailing value that should be included
+        "#;
+
+        let result = string_to_table(input, false, true, 2);
+        assert_eq!(
+            result,
+            vec![vec![
+                owned("colA", "val1"),
+                owned("col B", "val2   trailing value that should be included"),
+            ]]
+        );
+    }
+
+    #[test]
+    fn it_handles_empty_values_when_headerless_and_aligned_columns() {
+        let input = r#"
+            a multi-word value  b           d
+            1                        3-3    4
+                                                       last
+        "#;
+
+        let result = string_to_table(input, true, true, 2);
+        assert_eq!(
+            result,
+            vec![
+                vec![
+                    owned("Column1", "a multi-word value"),
+                    owned("Column2", "b"),
+                    owned("Column3", ""),
+                    owned("Column4", "d"),
+                    owned("Column5", "")
+                ],
+                vec![
+                    owned("Column1", "1"),
+                    owned("Column2", ""),
+                    owned("Column3", "3-3"),
+                    owned("Column4", "4"),
+                    owned("Column5", "")
+                ],
+                vec![
+                    owned("Column1", ""),
+                    owned("Column2", ""),
+                    owned("Column3", ""),
+                    owned("Column4", ""),
+                    owned("Column5", "last")
+                ],
+            ]
+        );
+    }
+
+    #[test]
+    fn input_is_parsed_correctly_if_either_option_works() {
+        let input = r#"
+                docker-registry   docker-registry=default                   docker-registry=default   172.30.78.158   5000/TCP
+                kubernetes        component=apiserver,provider=kubernetes   <none>                    172.30.0.2      443/TCP
+                kubernetes-ro     component=apiserver,provider=kubernetes   <none>                    172.30.0.1      80/TCP
+            "#;
+
+        let aligned_columns_headerless = string_to_table(input, true, true, 2);
+        let separator_headerless = string_to_table(input, true, false, 2);
+        let aligned_columns_with_headers = string_to_table(input, false, true, 2);
+        let separator_with_headers = string_to_table(input, false, false, 2);
+        assert_eq!(aligned_columns_headerless, separator_headerless);
+        assert_eq!(aligned_columns_with_headers, separator_with_headers);
+    }
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use super::FromSSV;
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromSSV {})?)
+    }
+}

crates/nu-command/src/commands/from_toml.rs

@@ -0,0 +1,104 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
+
+pub struct FromTOML;
+
+#[async_trait]
+impl WholeStreamCommand for FromTOML {
+    fn name(&self) -> &str {
+        "from toml"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from toml")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .toml and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_toml(args).await
+    }
+}
+
+pub fn convert_toml_value_to_nu_value(v: &toml::Value, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+    let span = tag.span;
+
+    match v {
+        toml::Value::Boolean(b) => UntaggedValue::boolean(*b).into_value(tag),
+        toml::Value::Integer(n) => UntaggedValue::int(*n).into_value(tag),
+        toml::Value::Float(n) => UntaggedValue::decimal_from_float(*n, span).into_value(tag),
+        toml::Value::String(s) => {
+            UntaggedValue::Primitive(Primitive::String(String::from(s))).into_value(tag)
+        }
+        toml::Value::Array(a) => UntaggedValue::Table(
+            a.iter()
+                .map(|x| convert_toml_value_to_nu_value(x, &tag))
+                .collect(),
+        )
+        .into_value(tag),
+        toml::Value::Datetime(dt) => {
+            UntaggedValue::Primitive(Primitive::String(dt.to_string())).into_value(tag)
+        }
+        toml::Value::Table(t) => {
+            let mut collected = TaggedDictBuilder::new(&tag);
+
+            for (k, v) in t.iter() {
+                collected.insert_value(k.clone(), convert_toml_value_to_nu_value(v, &tag));
+            }
+
+            collected.into_value()
+        }
+    }
+}
+
+pub fn from_toml_string_to_value(s: String, tag: impl Into<Tag>) -> Result<Value, toml::de::Error> {
+    let v: toml::Value = s.parse::<toml::Value>()?;
+    Ok(convert_toml_value_to_nu_value(&v, tag))
+}
+
+pub async fn from_toml(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.name_tag();
+    let input = args.input;
+
+    let concat_string = input.collect_string(tag.clone()).await?;
+    Ok(
+        match from_toml_string_to_value(concat_string.item, tag.clone()) {
+            Ok(x) => match x {
+                Value {
+                    value: UntaggedValue::Table(list),
+                    ..
+                } => futures::stream::iter(list.into_iter().map(ReturnSuccess::value))
+                    .to_output_stream(),
+                x => OutputStream::one(ReturnSuccess::value(x)),
+            },
+            Err(_) => {
+                return Err(ShellError::labeled_error_with_secondary(
+                    "Could not parse as TOML",
+                    "input cannot be parsed as TOML",
+                    &tag,
+                    "value originates from here",
+                    concat_string.tag,
+                ))
+            }
+        },
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromTOML;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromTOML {})?)
+    }
+}

crates/nu-command/src/commands/from_tsv.rs

@@ -0,0 +1,55 @@
+use crate::commands::from_delimited_data::from_delimited_data;
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::Signature;
+
+pub struct FromTSV;
+
+#[derive(Deserialize)]
+pub struct FromTSVArgs {
+    headerless: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FromTSV {
+    fn name(&self) -> &str {
+        "from tsv"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from tsv").switch(
+            "headerless",
+            "don't treat the first row as column names",
+            None,
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .tsv and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_tsv(args).await
+    }
+}
+
+async fn from_tsv(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let (FromTSVArgs { headerless }, input) = args.process().await?;
+
+    from_delimited_data(headerless, '\t', "TSV", input, name).await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromTSV;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromTSV {})?)
+    }
+}

crates/nu-command/src/commands/from_url.rs

@@ -0,0 +1,67 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue};
+
+pub struct FromURL;
+
+#[async_trait]
+impl WholeStreamCommand for FromURL {
+    fn name(&self) -> &str {
+        "from url"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from url")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse url-encoded string as a table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_url(args).await
+    }
+}
+
+async fn from_url(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.name_tag();
+    let input = args.input;
+
+    let concat_string = input.collect_string(tag.clone()).await?;
+
+    let result = serde_urlencoded::from_str::<Vec<(String, String)>>(&concat_string.item);
+
+    match result {
+        Ok(result) => {
+            let mut row = TaggedDictBuilder::new(tag);
+
+            for (k, v) in result {
+                row.insert_untagged(k, UntaggedValue::string(v));
+            }
+
+            Ok(OutputStream::one(ReturnSuccess::value(row.into_value())))
+        }
+        _ => Err(ShellError::labeled_error_with_secondary(
+            "String not compatible with url-encoding",
+            "input not url-encoded",
+            tag,
+            "value originates from here",
+            concat_string.tag,
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromURL;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromURL {})?)
+    }
+}

crates/nu-command/src/commands/from_vcf.rs

@@ -0,0 +1,107 @@
+extern crate ical;
+use crate::prelude::*;
+use ical::parser::vcard::component::*;
+use ical::property::Property;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
+
+pub struct FromVcf;
+
+#[async_trait]
+impl WholeStreamCommand for FromVcf {
+    fn name(&self) -> &str {
+        "from vcf"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from vcf")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .vcf and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_vcf(args).await
+    }
+}
+
+async fn from_vcf(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.name_tag();
+    let input = args.input;
+
+    let input_string = input.collect_string(tag.clone()).await?.item;
+    let input_bytes = input_string.into_bytes();
+    let cursor = std::io::Cursor::new(input_bytes);
+    let parser = ical::VcardParser::new(cursor);
+
+    let iter = parser.map(move |contact| match contact {
+        Ok(c) => ReturnSuccess::value(contact_to_value(c, tag.clone())),
+        Err(_) => Err(ShellError::labeled_error(
+            "Could not parse as .vcf",
+            "input cannot be parsed as .vcf",
+            tag.clone(),
+        )),
+    });
+
+    Ok(futures::stream::iter(iter).to_output_stream())
+}
+
+fn contact_to_value(contact: VcardContact, tag: Tag) -> Value {
+    let mut row = TaggedDictBuilder::new(tag.clone());
+    row.insert_untagged("properties", properties_to_value(contact.properties, tag));
+    row.into_value()
+}
+
+fn properties_to_value(properties: Vec<Property>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &properties
+            .into_iter()
+            .map(|prop| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+
+                let name = UntaggedValue::string(prop.name);
+                let value = match prop.value {
+                    Some(val) => UntaggedValue::string(val),
+                    None => UntaggedValue::Primitive(Primitive::Nothing),
+                };
+                let params = match prop.params {
+                    Some(param_list) => params_to_value(param_list, tag.clone()).into(),
+                    None => UntaggedValue::Primitive(Primitive::Nothing),
+                };
+
+                row.insert_untagged("name", name);
+                row.insert_untagged("value", value);
+                row.insert_untagged("params", params);
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn params_to_value(params: Vec<(String, Vec<String>)>, tag: Tag) -> Value {
+    let mut row = TaggedDictBuilder::new(tag);
+
+    for (param_name, param_values) in params {
+        let values: Vec<Value> = param_values.into_iter().map(|val| val.into()).collect();
+        let values = UntaggedValue::table(&values);
+        row.insert_untagged(param_name, values);
+    }
+
+    row.into_value()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromVcf;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromVcf {})?)
+    }
+}

crates/nu-command/src/commands/from_xlsx.rs

@@ -0,0 +1,105 @@
+use crate::prelude::*;
+use calamine::*;
+use nu_data::TaggedListBuilder;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue};
+use std::io::Cursor;
+
+pub struct FromXLSX;
+
+#[derive(Deserialize)]
+pub struct FromXLSXArgs {
+    headerless: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FromXLSX {
+    fn name(&self) -> &str {
+        "from xlsx"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from xlsx").switch(
+            "headerless",
+            "don't treat the first row as column names",
+            None,
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Parse binary Excel(.xlsx) data and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_xlsx(args).await
+    }
+}
+
+async fn from_xlsx(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let span = tag.span;
+    let (
+        FromXLSXArgs {
+            headerless: _headerless,
+        },
+        input,
+    ) = args.process().await?;
+    let value = input.collect_binary(tag.clone()).await?;
+
+    let buf: Cursor<Vec<u8>> = Cursor::new(value.item);
+    let mut xls = Xlsx::<_>::new(buf).map_err(|_| {
+        ShellError::labeled_error("Could not load xlsx file", "could not load xlsx file", &tag)
+    })?;
+
+    let mut dict = TaggedDictBuilder::new(&tag);
+
+    let sheet_names = xls.sheet_names().to_owned();
+
+    for sheet_name in &sheet_names {
+        let mut sheet_output = TaggedListBuilder::new(&tag);
+
+        if let Some(Ok(current_sheet)) = xls.worksheet_range(sheet_name) {
+            for row in current_sheet.rows() {
+                let mut row_output = TaggedDictBuilder::new(&tag);
+                for (i, cell) in row.iter().enumerate() {
+                    let value = match cell {
+                        DataType::Empty => UntaggedValue::nothing(),
+                        DataType::String(s) => UntaggedValue::string(s),
+                        DataType::Float(f) => UntaggedValue::decimal_from_float(*f, span),
+                        DataType::Int(i) => UntaggedValue::int(*i),
+                        DataType::Bool(b) => UntaggedValue::boolean(*b),
+                        _ => UntaggedValue::nothing(),
+                    };
+
+                    row_output.insert_untagged(&format!("Column{}", i), value);
+                }
+
+                sheet_output.push_untagged(row_output.into_untagged_value());
+            }
+
+            dict.insert_untagged(sheet_name, sheet_output.into_untagged_value());
+        } else {
+            return Err(ShellError::labeled_error(
+                "Could not load sheet",
+                "could not load sheet",
+                &tag,
+            ));
+        }
+    }
+
+    Ok(OutputStream::one(ReturnSuccess::value(dict.into_value())))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromXLSX;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromXLSX {})?)
+    }
+}

crates/nu-command/src/commands/from_xml.rs

@@ -0,0 +1,306 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
+
+pub struct FromXML;
+
+#[async_trait]
+impl WholeStreamCommand for FromXML {
+    fn name(&self) -> &str {
+        "from xml"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from xml")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .xml and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_xml(args).await
+    }
+}
+
+fn from_attributes_to_value(attributes: &[roxmltree::Attribute], tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+
+    let mut collected = TaggedDictBuilder::new(tag);
+    for a in attributes {
+        collected.insert_untagged(String::from(a.name()), UntaggedValue::string(a.value()));
+    }
+
+    collected.into_value()
+}
+
+fn from_node_to_value(n: &roxmltree::Node, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+
+    if n.is_element() {
+        let name = n.tag_name().name().trim().to_string();
+
+        let mut children_values = vec![];
+        for c in n.children() {
+            children_values.push(from_node_to_value(&c, &tag));
+        }
+
+        let children_values: Vec<Value> = children_values
+            .into_iter()
+            .filter(|x| match x {
+                Value {
+                    value: UntaggedValue::Primitive(Primitive::String(f)),
+                    ..
+                } => {
+                    !f.trim().is_empty() // non-whitespace characters?
+                }
+                _ => true,
+            })
+            .collect();
+
+        let mut collected = TaggedDictBuilder::new(&tag);
+
+        let attribute_value: Value = from_attributes_to_value(&n.attributes(), &tag);
+
+        let mut row = TaggedDictBuilder::new(&tag);
+        row.insert_untagged(
+            String::from("children"),
+            UntaggedValue::Table(children_values),
+        );
+        row.insert_untagged(String::from("attributes"), attribute_value);
+        collected.insert_untagged(name, row.into_value());
+
+        collected.into_value()
+    } else if n.is_comment() {
+        UntaggedValue::string("<comment>").into_value(tag)
+    } else if n.is_pi() {
+        UntaggedValue::string("<processing_instruction>").into_value(tag)
+    } else if n.is_text() {
+        match n.text() {
+            Some(text) => UntaggedValue::string(text).into_value(tag),
+            None => UntaggedValue::string("<error>").into_value(tag),
+        }
+    } else {
+        UntaggedValue::string("<unknown>").into_value(tag)
+    }
+}
+
+fn from_document_to_value(d: &roxmltree::Document, tag: impl Into<Tag>) -> Value {
+    from_node_to_value(&d.root_element(), tag)
+}
+
+pub fn from_xml_string_to_value(s: String, tag: impl Into<Tag>) -> Result<Value, roxmltree::Error> {
+    let parsed = roxmltree::Document::parse(&s)?;
+    Ok(from_document_to_value(&parsed, tag))
+}
+
+async fn from_xml(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.name_tag();
+    let input = args.input;
+
+    let concat_string = input.collect_string(tag.clone()).await?;
+
+    Ok(
+        match from_xml_string_to_value(concat_string.item, tag.clone()) {
+            Ok(x) => match x {
+                Value {
+                    value: UntaggedValue::Table(list),
+                    ..
+                } => futures::stream::iter(list.into_iter().map(ReturnSuccess::value))
+                    .to_output_stream(),
+                x => OutputStream::one(ReturnSuccess::value(x)),
+            },
+            Err(_) => {
+                return Err(ShellError::labeled_error_with_secondary(
+                    "Could not parse as XML",
+                    "input cannot be parsed as XML",
+                    &tag,
+                    "value originates from here",
+                    &concat_string.tag,
+                ))
+            }
+        },
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use crate::commands::from_xml;
+    use indexmap::IndexMap;
+    use nu_protocol::{UntaggedValue, Value};
+    use nu_source::*;
+
+    fn string(input: impl Into<String>) -> Value {
+        UntaggedValue::string(input.into()).into_untagged_value()
+    }
+
+    fn row(entries: IndexMap<String, Value>) -> Value {
+        UntaggedValue::row(entries).into_untagged_value()
+    }
+
+    fn table(list: &[Value]) -> Value {
+        UntaggedValue::table(list).into_untagged_value()
+    }
+
+    fn parse(xml: &str) -> Result<Value, roxmltree::Error> {
+        from_xml::from_xml_string_to_value(xml.to_string(), Tag::unknown())
+    }
+
+    #[test]
+    fn parses_empty_element() -> Result<(), roxmltree::Error> {
+        let source = "<nu></nu>";
+
+        assert_eq!(
+            parse(source)?,
+            row(indexmap! {
+                "nu".into() => row(indexmap! {
+                    "children".into() => table(&[]),
+                    "attributes".into() => row(indexmap! {})
+                })
+            })
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn parses_element_with_text() -> Result<(), roxmltree::Error> {
+        let source = "<nu>La era de los tres caballeros</nu>";
+
+        assert_eq!(
+            parse(source)?,
+            row(indexmap! {
+                "nu".into() => row(indexmap! {
+                    "children".into() => table(&[string("La era de los tres caballeros")]),
+                    "attributes".into() => row(indexmap! {})
+                })
+            })
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn parses_element_with_elements() -> Result<(), roxmltree::Error> {
+        let source = "\
+<nu>
+    <dev>Andrés</dev>
+    <dev>Jonathan</dev>
+    <dev>Yehuda</dev>
+</nu>";
+
+        assert_eq!(
+            parse(source)?,
+            row(indexmap! {
+                "nu".into() => row(indexmap! {
+                    "children".into() => table(&[
+                        row(indexmap! {
+                            "dev".into() => row(indexmap! {
+                                "children".into() => table(&[string("Andrés")]),
+                                "attributes".into() => row(indexmap! {})
+                            })
+                        }),
+                        row(indexmap! {
+                            "dev".into() => row(indexmap! {
+                                "children".into() => table(&[string("Jonathan")]),
+                                "attributes".into() => row(indexmap! {})
+                            })
+                        }),
+                        row(indexmap! {
+                            "dev".into() => row(indexmap! {
+                                "children".into() => table(&[string("Yehuda")]),
+                                "attributes".into() => row(indexmap! {})
+                            })
+                        })
+                    ]),
+                    "attributes".into() => row(indexmap! {})
+                })
+            })
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn parses_element_with_attribute() -> Result<(), roxmltree::Error> {
+        let source = "\
+<nu version=\"2.0\">
+</nu>";
+
+        assert_eq!(
+            parse(source)?,
+            row(indexmap! {
+                "nu".into() => row(indexmap! {
+                    "children".into() => table(&[]),
+                    "attributes".into() => row(indexmap! {
+                        "version".into() => string("2.0")
+                    })
+                })
+            })
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn parses_element_with_attribute_and_element() -> Result<(), roxmltree::Error> {
+        let source = "\
+<nu version=\"2.0\">
+    <version>2.0</version>
+</nu>";
+
+        assert_eq!(
+            parse(source)?,
+            row(indexmap! {
+                "nu".into() => row(indexmap! {
+                    "children".into() => table(&[
+                           row(indexmap! {
+                                "version".into() => row(indexmap! {
+                                    "children".into() => table(&[string("2.0")]),
+                                    "attributes".into() => row(indexmap! {})
+                                })
+                          })
+                    ]),
+                    "attributes".into() => row(indexmap! {
+                        "version".into() => string("2.0")
+                    })
+                })
+            })
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn parses_element_with_multiple_attributes() -> Result<(), roxmltree::Error> {
+        let source = "\
+<nu version=\"2.0\" age=\"25\">
+</nu>";
+
+        assert_eq!(
+            parse(source)?,
+            row(indexmap! {
+                "nu".into() => row(indexmap! {
+                    "children".into() => table(&[]),
+                    "attributes".into() => row(indexmap! {
+                        "version".into() => string("2.0"),
+                        "age".into() => string("25")
+                    })
+                })
+            })
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use super::FromXML;
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromXML {})?)
+    }
+}

crates/nu-command/src/commands/from_yaml.rs

@@ -0,0 +1,208 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, Signature, TaggedDictBuilder, UntaggedValue, Value};
+
+pub struct FromYAML;
+
+#[async_trait]
+impl WholeStreamCommand for FromYAML {
+    fn name(&self) -> &str {
+        "from yaml"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from yaml")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .yaml/.yml and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_yaml(args).await
+    }
+}
+
+pub struct FromYML;
+
+#[async_trait]
+impl WholeStreamCommand for FromYML {
+    fn name(&self) -> &str {
+        "from yml"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from yml")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .yaml/.yml and create table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_yaml(args).await
+    }
+}
+
+fn convert_yaml_value_to_nu_value(
+    v: &serde_yaml::Value,
+    tag: impl Into<Tag>,
+) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    let span = tag.span;
+
+    let err_not_compatible_number = ShellError::labeled_error(
+        "Expected a compatible number",
+        "expected a compatible number",
+        &tag,
+    );
+    Ok(match v {
+        serde_yaml::Value::Bool(b) => UntaggedValue::boolean(*b).into_value(tag),
+        serde_yaml::Value::Number(n) if n.is_i64() => {
+            UntaggedValue::int(n.as_i64().ok_or(err_not_compatible_number)?).into_value(tag)
+        }
+        serde_yaml::Value::Number(n) if n.is_f64() => {
+            UntaggedValue::decimal_from_float(n.as_f64().ok_or(err_not_compatible_number)?, span)
+                .into_value(tag)
+        }
+        serde_yaml::Value::String(s) => UntaggedValue::string(s).into_value(tag),
+        serde_yaml::Value::Sequence(a) => {
+            let result: Result<Vec<Value>, ShellError> = a
+                .iter()
+                .map(|x| convert_yaml_value_to_nu_value(x, &tag))
+                .collect();
+            UntaggedValue::Table(result?).into_value(tag)
+        }
+        serde_yaml::Value::Mapping(t) => {
+            let mut collected = TaggedDictBuilder::new(&tag);
+
+            for (k, v) in t.iter() {
+                // A ShellError that we re-use multiple times in the Mapping scenario
+                let err_unexpected_map = ShellError::labeled_error(
+                    format!("Unexpected YAML:\nKey: {:?}\nValue: {:?}", k, v),
+                    "unexpected",
+                    tag.clone(),
+                );
+                match (k, v) {
+                    (serde_yaml::Value::String(k), _) => {
+                        collected.insert_value(k.clone(), convert_yaml_value_to_nu_value(v, &tag)?);
+                    }
+                    // Hard-code fix for cases where "v" is a string without quotations with double curly braces
+                    // e.g. k = value
+                    // value: {{ something }}
+                    // Strangely, serde_yaml returns
+                    // "value" -> Mapping(Mapping { map: {Mapping(Mapping { map: {String("something"): Null} }): Null} })
+                    (serde_yaml::Value::Mapping(m), serde_yaml::Value::Null) => {
+                        return m
+                            .iter()
+                            .take(1)
+                            .collect_vec()
+                            .first()
+                            .and_then(|e| match e {
+                                (serde_yaml::Value::String(s), serde_yaml::Value::Null) => Some(
+                                    UntaggedValue::string("{{ ".to_owned() + &s + " }}")
+                                        .into_value(tag),
+                                ),
+                                _ => None,
+                            })
+                            .ok_or(err_unexpected_map);
+                    }
+                    (_, _) => {
+                        return Err(err_unexpected_map);
+                    }
+                }
+            }
+
+            collected.into_value()
+        }
+        serde_yaml::Value::Null => UntaggedValue::Primitive(Primitive::Nothing).into_value(tag),
+        x => unimplemented!("Unsupported yaml case: {:?}", x),
+    })
+}
+
+pub fn from_yaml_string_to_value(s: String, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    let v: serde_yaml::Value = serde_yaml::from_str(&s).map_err(|x| {
+        ShellError::labeled_error(
+            format!("Could not load yaml: {}", x),
+            "could not load yaml from text",
+            &tag,
+        )
+    })?;
+    Ok(convert_yaml_value_to_nu_value(&v, tag)?)
+}
+
+async fn from_yaml(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.name_tag();
+    let input = args.input;
+
+    let concat_string = input.collect_string(tag.clone()).await?;
+
+    match from_yaml_string_to_value(concat_string.item, tag.clone()) {
+        Ok(x) => match x {
+            Value {
+                value: UntaggedValue::Table(list),
+                ..
+            } => Ok(futures::stream::iter(list).to_output_stream()),
+            x => Ok(OutputStream::one(x)),
+        },
+        Err(_) => Err(ShellError::labeled_error_with_secondary(
+            "Could not parse as YAML",
+            "input cannot be parsed as YAML",
+            &tag,
+            "value originates from here",
+            &concat_string.tag,
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ShellError;
+    use super::*;
+    use nu_protocol::row;
+    use nu_test_support::value::string;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FromYAML {})?)
+    }
+
+    #[test]
+    fn test_problematic_yaml() {
+        struct TestCase {
+            description: &'static str,
+            input: &'static str,
+            expected: Result<Value, ShellError>,
+        }
+        let tt: Vec<TestCase> = vec![
+            TestCase {
+                description: "Double Curly Braces With Quotes",
+                input: r#"value: "{{ something }}""#,
+                expected: Ok(row!["value".to_owned() => string("{{ something }}")]),
+            },
+            TestCase {
+                description: "Double Curly Braces Without Quotes",
+                input: r#"value: {{ something }}"#,
+                expected: Ok(row!["value".to_owned() => string("{{ something }}")]),
+            },
+        ];
+        for tc in tt.into_iter() {
+            let actual = from_yaml_string_to_value(tc.input.to_owned(), Tag::default());
+            if actual.is_err() {
+                assert!(
+                    tc.expected.is_err(),
+                    "actual is Err for test:\nTest Description {}\nErr: {:?}",
+                    tc.description,
+                    actual
+                );
+            } else {
+                assert_eq!(actual, tc.expected, "{}", tc.description);
+            }
+        }
+    }
+}

crates/nu-command/src/commands/get.rs

@@ -0,0 +1,270 @@
+use crate::prelude::*;
+use indexmap::set::IndexSet;
+use log::trace;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    did_you_mean, ColumnPath, Dictionary, PathMember, Primitive, ReturnSuccess, Signature,
+    SyntaxShape, UnspannedPathMember, UntaggedValue, Value,
+};
+use nu_source::HasFallibleSpan;
+use nu_value_ext::get_data_by_column_path;
+
+pub struct Get;
+
+#[derive(Deserialize)]
+pub struct GetArgs {
+    rest: Vec<ColumnPath>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Get {
+    fn name(&self) -> &str {
+        "get"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("get").rest(
+            SyntaxShape::ColumnPath,
+            "optionally return additional data by path",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Open given cells as text."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        get(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Extract the name of files as a list",
+                example: "ls | get name",
+                result: None,
+            },
+            Example {
+                description: "Extract the cpu list from the sys information",
+                example: "sys | get cpu",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn get(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (GetArgs { rest: column_paths }, mut input) = args.process().await?;
+    if column_paths.is_empty() {
+        let vec = input.drain_vec().await;
+
+        let descs = nu_protocol::merge_descriptors(&vec);
+
+        Ok(futures::stream::iter(descs.into_iter().map(ReturnSuccess::value)).to_output_stream())
+    } else {
+        trace!("get {:?}", column_paths);
+        let output_stream = input
+            .map(move |item| {
+                let output = column_paths
+                    .iter()
+                    .map(move |path| get_output(&item, path))
+                    .flatten()
+                    .collect::<Vec<_>>();
+                futures::stream::iter(output)
+            })
+            .flatten()
+            .to_output_stream();
+        Ok(output_stream)
+    }
+}
+
+fn get_output(item: &Value, path: &ColumnPath) -> Vec<Result<ReturnSuccess, ShellError>> {
+    match get_column_path(path, item) {
+        Ok(Value {
+            value: UntaggedValue::Primitive(Primitive::Nothing),
+            ..
+        }) => vec![],
+        Ok(Value {
+            value: UntaggedValue::Table(rows),
+            ..
+        }) => rows.into_iter().map(ReturnSuccess::value).collect(),
+        Ok(other) => vec![ReturnSuccess::value(other)],
+        Err(reason) => vec![ReturnSuccess::value(
+            UntaggedValue::Error(reason).into_untagged_value(),
+        )],
+    }
+}
+
+pub fn get_column_path(path: &ColumnPath, obj: &Value) -> Result<Value, ShellError> {
+    get_data_by_column_path(obj, path, move |obj_source, column_path_tried, error| {
+        let path_members_span = path.maybe_span().unwrap_or_else(Span::unknown);
+
+        match &obj_source.value {
+            UntaggedValue::Table(rows) => {
+                return get_column_path_from_table_error(
+                    rows,
+                    column_path_tried,
+                    &path_members_span,
+                );
+            }
+            UntaggedValue::Row(columns) => {
+                if let Some(error) = get_column_from_row_error(
+                    columns,
+                    column_path_tried,
+                    &path_members_span,
+                    obj_source,
+                ) {
+                    return error;
+                }
+            }
+            _ => {}
+        }
+
+        if let Some(suggestions) = did_you_mean(&obj_source, column_path_tried.as_string()) {
+            ShellError::labeled_error(
+                "Unknown column",
+                format!("did you mean '{}'?", suggestions[0]),
+                column_path_tried.span.since(path_members_span),
+            )
+        } else {
+            error
+        }
+    })
+}
+
+pub fn get_column_path_from_table_error(
+    rows: &[Value],
+    column_path_tried: &PathMember,
+    path_members_span: &Span,
+) -> ShellError {
+    match column_path_tried {
+        PathMember {
+            unspanned: UnspannedPathMember::String(column),
+            ..
+        } => {
+            let primary_label = format!("There isn't a column named '{}'", &column);
+
+            let suggestions: IndexSet<_> = rows
+                .iter()
+                .filter_map(|r| did_you_mean(&r, column_path_tried.as_string()))
+                .map(|s| s[0].to_owned())
+                .collect();
+            let mut existing_columns: IndexSet<_> = IndexSet::default();
+            let mut names: Vec<String> = vec![];
+
+            for row in rows {
+                for field in row.data_descriptors() {
+                    if !existing_columns.contains(&field[..]) {
+                        existing_columns.insert(field.clone());
+                        names.push(field);
+                    }
+                }
+            }
+
+            if names.is_empty() {
+                ShellError::labeled_error_with_secondary(
+                    "Unknown column",
+                    primary_label,
+                    column_path_tried.span,
+                    "Appears to contain rows. Try indexing instead.",
+                    column_path_tried.span.since(path_members_span),
+                )
+            } else {
+                ShellError::labeled_error_with_secondary(
+                    "Unknown column",
+                    primary_label,
+                    column_path_tried.span,
+                    format!(
+                        "Perhaps you meant '{}'? Columns available: {}",
+                        suggestions
+                            .iter()
+                            .map(|x| x.to_owned())
+                            .collect::<Vec<String>>()
+                            .join(","),
+                        names.join(", ")
+                    ),
+                    column_path_tried.span.since(path_members_span),
+                )
+            }
+        }
+        PathMember {
+            unspanned: UnspannedPathMember::Int(idx),
+            ..
+        } => {
+            let total = rows.len();
+
+            let secondary_label = if total == 1 {
+                "The table only has 1 row".to_owned()
+            } else {
+                format!("The table only has {} rows (0 to {})", total, total - 1)
+            };
+
+            ShellError::labeled_error_with_secondary(
+                "Row not found",
+                format!("There isn't a row indexed at {}", idx),
+                column_path_tried.span,
+                secondary_label,
+                column_path_tried.span.since(path_members_span),
+            )
+        }
+    }
+}
+
+pub fn get_column_from_row_error(
+    columns: &Dictionary,
+    column_path_tried: &PathMember,
+    path_members_span: &Span,
+    obj_source: &Value,
+) -> Option<ShellError> {
+    match column_path_tried {
+        PathMember {
+            unspanned: UnspannedPathMember::String(column),
+            ..
+        } => {
+            let primary_label = format!("There isn't a column named '{}'", &column);
+
+            if let Some(suggestions) = did_you_mean(&obj_source, column_path_tried.as_string()) {
+                Some(ShellError::labeled_error_with_secondary(
+                    "Unknown column",
+                    primary_label,
+                    column_path_tried.span,
+                    format!(
+                        "Perhaps you meant '{}'? Columns available: {}",
+                        suggestions[0],
+                        &obj_source.data_descriptors().join(", ")
+                    ),
+                    column_path_tried.span.since(path_members_span),
+                ))
+            } else {
+                None
+            }
+        }
+        PathMember {
+            unspanned: UnspannedPathMember::Int(idx),
+            ..
+        } => Some(ShellError::labeled_error_with_secondary(
+            "No rows available",
+            format!("A row at '{}' can't be indexed.", &idx),
+            column_path_tried.span,
+            format!(
+                "Appears to contain columns. Columns available: {}",
+                columns.keys().join(", ")
+            ),
+            column_path_tried.span.since(path_members_span),
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Get;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Get {})?)
+    }
+}

crates/nu-command/src/commands/group_by.rs

@@ -0,0 +1,328 @@
+use crate::prelude::*;
+use crate::utils::suggestions::suggestions;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+use nu_value_ext::as_string;
+
+pub struct Command;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    grouper: Option<Value>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "group-by"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("group-by").optional(
+            "grouper",
+            SyntaxShape::Any,
+            "the grouper value to use",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Create a new table grouped."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        group_by(args).await
+    }
+
+    #[allow(clippy::unwrap_used)]
+    fn examples(&self) -> Vec<Example> {
+        use nu_data::value::date_naive_from_str as date;
+
+        vec![
+            Example {
+                description: "group items by column named \"type\"",
+                example: r#"ls | group-by type"#,
+                result: Some(vec![UntaggedValue::row(indexmap! {
+                    "File".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::row(indexmap! {
+                                "name".to_string() =>          UntaggedValue::string("Andrés.txt").into(),
+                                "type".to_string() =>                UntaggedValue::string("File").into(),
+                            "chickens".to_string() =>                       UntaggedValue::int(10).into(),
+                            "modified".to_string() => date("2019-07-23".tagged_unknown()).unwrap().into(),
+                        }).into(),
+                        UntaggedValue::row(indexmap! {
+                                "name".to_string() =>          UntaggedValue::string("Andrés.txt").into(),
+                                "type".to_string() =>                UntaggedValue::string("File").into(),
+                            "chickens".to_string() =>                       UntaggedValue::int(20).into(),
+                            "modified".to_string() => date("2019-09-24".tagged_unknown()).unwrap().into(),
+                        }).into(),
+                    ]).into(),
+                    "Dir".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::row(indexmap! {
+                                "name".to_string() =>            UntaggedValue::string("Jonathan").into(),
+                                "type".to_string() =>                 UntaggedValue::string("Dir").into(),
+                            "chickens".to_string() =>                        UntaggedValue::int(5).into(),
+                            "modified".to_string() => date("2019-07-23".tagged_unknown()).unwrap().into(),
+                        }).into(),
+                        UntaggedValue::row(indexmap! {
+                                "name".to_string() =>              UntaggedValue::string("Yehuda").into(),
+                                "type".to_string() =>                 UntaggedValue::string("Dir").into(),
+                            "chickens".to_string() =>                        UntaggedValue::int(4).into(),
+                            "modified".to_string() => date("2019-09-24".tagged_unknown()).unwrap().into(),
+                        }).into(),
+                    ]).into(),
+                })
+                .into()]),
+            },
+            Example {
+                description: "you can also group by raw values by leaving out the argument",
+                example: "echo [1 3 1 3 2 1 1] | group-by",
+                result: Some(vec![UntaggedValue::row(indexmap! {
+                    "1".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(1).into(),
+                    ]).into(),
+
+                    "3".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::int(3).into(),
+                        UntaggedValue::int(3).into(),
+                    ]).into(),
+
+                    "2".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::int(2).into(),
+                    ]).into(),
+                })
+                .into()]),
+            },
+            Example {
+                description:
+                    "use the block form to generate a grouping key when each row gets processed",
+                example: "echo [1 3 1 3 2 1 1] | group-by { = ($it - 1) mod 3 }",
+                result: Some(vec![UntaggedValue::row(indexmap! {
+                    "0".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(1).into(),
+                        UntaggedValue::int(1).into(),
+
+                    ]).into(),
+                    "2".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::int(3).into(),
+                        UntaggedValue::int(3).into(),
+                    ]).into(),
+                    "1".to_string() => UntaggedValue::Table(vec![
+                        UntaggedValue::int(2).into(),
+                    ]).into(),
+                })
+                .into()]),
+            },
+        ]
+    }
+}
+
+enum Grouper {
+    ByColumn(Option<Tagged<String>>),
+    ByBlock,
+}
+
+pub async fn group_by(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let context = Arc::new(EvaluationContext::from_raw(&args));
+    let (Arguments { grouper }, input) = args.process().await?;
+
+    let values: Vec<Value> = input.collect().await;
+    let mut keys: Vec<Result<String, ShellError>> = vec![];
+    let mut group_strategy = Grouper::ByColumn(None);
+
+    match grouper {
+        Some(Value {
+            value: UntaggedValue::Block(block_given),
+            ..
+        }) => {
+            let block = Arc::new(block_given);
+            let error_key = "error";
+
+            for value in values.iter() {
+                let run = block.clone();
+                let context = context.clone();
+
+                match crate::commands::each::process_row(run, context, value.clone()).await {
+                    Ok(mut s) => {
+                        let collection: Vec<Result<ReturnSuccess, ShellError>> =
+                            s.drain_vec().await;
+
+                        if collection.len() > 1 {
+                            return Err(ShellError::labeled_error(
+                                "expected one value from the block",
+                                "requires a table with one value for grouping",
+                                &name,
+                            ));
+                        }
+
+                        let value = match collection.get(0) {
+                            Some(Ok(return_value)) => {
+                                return_value.raw_value().unwrap_or_else(|| {
+                                    UntaggedValue::string(error_key).into_value(&name)
+                                })
+                            }
+                            Some(Err(_)) | None => {
+                                UntaggedValue::string(error_key).into_value(&name)
+                            }
+                        };
+
+                        keys.push(as_string(&value));
+                    }
+                    Err(_) => {
+                        keys.push(Ok(error_key.into()));
+                    }
+                }
+            }
+
+            group_strategy = Grouper::ByBlock;
+        }
+        Some(other) => {
+            group_strategy = Grouper::ByColumn(Some(as_string(&other)?.tagged(&name)));
+        }
+        _ => {}
+    }
+
+    if values.is_empty() {
+        return Err(ShellError::labeled_error(
+            "expected table from pipeline",
+            "requires a table input",
+            name,
+        ));
+    }
+
+    let first = values[0].clone();
+
+    let name = if first.tag.anchor().is_some() {
+        first.tag
+    } else {
+        name
+    };
+
+    let values = UntaggedValue::table(&values).into_value(&name);
+
+    let group_value = match group_strategy {
+        Grouper::ByBlock => {
+            let map = keys.clone();
+
+            let block = Box::new(move |idx: usize, row: &Value| match map.get(idx) {
+                Some(Ok(key)) => Ok(key.clone()),
+                Some(Err(reason)) => Err(reason.clone()),
+                None => as_string(row),
+            });
+
+            nu_data::utils::group(&values, &Some(block), name)
+        }
+        Grouper::ByColumn(column_name) => group(&column_name, &values, &name),
+    };
+
+    Ok(OutputStream::one(ReturnSuccess::value(group_value?)))
+}
+
+pub fn group(
+    column_name: &Option<Tagged<String>>,
+    values: &Value,
+    tag: impl Into<Tag>,
+) -> Result<Value, ShellError> {
+    let name = tag.into();
+
+    let grouper = if let Some(column_name) = column_name {
+        Grouper::ByColumn(Some(column_name.clone()))
+    } else {
+        Grouper::ByColumn(None)
+    };
+
+    match grouper {
+        Grouper::ByColumn(Some(column_name)) => {
+            let block = Box::new(move |_, row: &Value| {
+                match row.get_data_by_key(column_name.borrow_spanned()) {
+                    Some(group_key) => Ok(as_string(&group_key)?),
+                    None => Err(suggestions(column_name.borrow_tagged(), &row)),
+                }
+            });
+
+            nu_data::utils::group(&values, &Some(block), &name)
+        }
+        Grouper::ByColumn(None) => {
+            let block = Box::new(move |_, row: &Value| as_string(row));
+
+            nu_data::utils::group(&values, &Some(block), &name)
+        }
+        Grouper::ByBlock => Err(ShellError::unimplemented(
+            "Block not implemented: This should never happen.",
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::group;
+    use nu_data::utils::helpers::committers;
+    use nu_errors::ShellError;
+    use nu_source::*;
+    use nu_test_support::value::{date, int, row, string, table};
+
+    #[test]
+    fn groups_table_by_date_column() -> Result<(), ShellError> {
+        let for_key = Some(String::from("date").tagged_unknown());
+        let sample = table(&committers());
+
+        assert_eq!(
+            group(&for_key, &sample, Tag::unknown())?,
+            row(indexmap! {
+                "2019-07-23".into() =>  table(&[
+                    row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => date("2019-07-23"), "chickens".into() => int(10) }),
+                    row(indexmap!{"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => date("2019-07-23"), "chickens".into() =>  int(5) }),
+                    row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => date("2019-07-23"), "chickens".into() =>  int(2) })
+                ]),
+                "2019-10-10".into() =>  table(&[
+                    row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => date("2019-10-10"), "chickens".into() =>  int(6) }),
+                    row(indexmap!{"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => date("2019-10-10"), "chickens".into() => int(15) }),
+                    row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => date("2019-10-10"), "chickens".into() => int(30) })
+                ]),
+                "2019-09-24".into() =>  table(&[
+                    row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => date("2019-09-24"), "chickens".into() => int(20) }),
+                    row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => date("2019-09-24"), "chickens".into() =>  int(4) }),
+                    row(indexmap!{"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => date("2019-09-24"), "chickens".into() => int(10) })
+                ]),
+            })
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn groups_table_by_country_column() -> Result<(), ShellError> {
+        let for_key = Some(String::from("country").tagged_unknown());
+        let sample = table(&committers());
+
+        assert_eq!(
+            group(&for_key, &sample, Tag::unknown())?,
+            row(indexmap! {
+                "EC".into() =>  table(&[
+                    row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => date("2019-07-23"), "chickens".into() => int(10) }),
+                    row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => date("2019-09-24"), "chickens".into() => int(20) }),
+                    row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => date("2019-10-10"), "chickens".into() => int(30) })
+                ]),
+                "NZ".into() =>  table(&[
+                    row(indexmap!{"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => date("2019-07-23"), "chickens".into() =>  int(5) }),
+                    row(indexmap!{"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => date("2019-10-10"), "chickens".into() => int(15) }),
+                    row(indexmap!{"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => date("2019-09-24"), "chickens".into() => int(10) })
+                ]),
+                "US".into() =>  table(&[
+                    row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => date("2019-10-10"), "chickens".into() =>  int(6) }),
+                    row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => date("2019-09-24"), "chickens".into() =>  int(4) }),
+                    row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => date("2019-07-23"), "chickens".into() =>  int(2) }),
+                ]),
+            })
+        );
+
+        Ok(())
+    }
+}

crates/nu-command/src/commands/group_by_date.rs

@@ -0,0 +1,144 @@
+use crate::prelude::*;
+use crate::utils::suggestions::suggestions;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct GroupByDate;
+
+#[derive(Deserialize)]
+pub struct GroupByDateArgs {
+    column_name: Option<Tagged<String>>,
+    format: Option<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for GroupByDate {
+    fn name(&self) -> &str {
+        "group-by date"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("group-by date")
+            .optional(
+                "column_name",
+                SyntaxShape::String,
+                "the name of the column to group by",
+            )
+            .named(
+                "format",
+                SyntaxShape::String,
+                "Specify date and time formatting",
+                Some('f'),
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "creates a table grouped by date."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        group_by_date(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Group files by type",
+            example: "ls | group-by date --format '%d/%m/%Y'",
+            result: None,
+        }]
+    }
+}
+
+enum Grouper {
+    ByDate(Option<Tagged<String>>),
+}
+
+enum GroupByColumn {
+    Name(Option<Tagged<String>>),
+}
+
+pub async fn group_by_date(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let (
+        GroupByDateArgs {
+            column_name,
+            format,
+        },
+        input,
+    ) = args.process().await?;
+    let values: Vec<Value> = input.collect().await;
+
+    if values.is_empty() {
+        Err(ShellError::labeled_error(
+            "Expected table from pipeline",
+            "requires a table input",
+            name,
+        ))
+    } else {
+        let values = UntaggedValue::table(&values).into_value(&name);
+
+        let grouper_column = if let Some(column_name) = column_name {
+            GroupByColumn::Name(Some(column_name))
+        } else {
+            GroupByColumn::Name(None)
+        };
+
+        let grouper_date = if let Some(date_format) = format {
+            Grouper::ByDate(Some(date_format))
+        } else {
+            Grouper::ByDate(None)
+        };
+
+        let value_result = match (grouper_date, grouper_column) {
+            (Grouper::ByDate(None), GroupByColumn::Name(None)) => {
+                let block = Box::new(move |_, row: &Value| row.format("%Y-%m-%d"));
+
+                nu_data::utils::group(&values, &Some(block), &name)
+            }
+            (Grouper::ByDate(None), GroupByColumn::Name(Some(column_name))) => {
+                let block = Box::new(move |_, row: &Value| {
+                    let group_key = row
+                        .get_data_by_key(column_name.borrow_spanned())
+                        .ok_or_else(|| suggestions(column_name.borrow_tagged(), &row));
+
+                    group_key?.format("%Y-%m-%d")
+                });
+
+                nu_data::utils::group(&values, &Some(block), &name)
+            }
+            (Grouper::ByDate(Some(fmt)), GroupByColumn::Name(None)) => {
+                let block = Box::new(move |_, row: &Value| row.format(&fmt));
+
+                nu_data::utils::group(&values, &Some(block), &name)
+            }
+            (Grouper::ByDate(Some(fmt)), GroupByColumn::Name(Some(column_name))) => {
+                let block = Box::new(move |_, row: &Value| {
+                    let group_key = row
+                        .get_data_by_key(column_name.borrow_spanned())
+                        .ok_or_else(|| suggestions(column_name.borrow_tagged(), &row));
+
+                    group_key?.format(&fmt)
+                });
+
+                nu_data::utils::group(&values, &Some(block), &name)
+            }
+        };
+
+        Ok(OutputStream::one(ReturnSuccess::value(value_result?)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::GroupByDate;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(GroupByDate {})?)
+    }
+}

crates/nu-command/src/commands/hash_/base64_.rs

@@ -0,0 +1,304 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::ShellTypeName;
+use nu_protocol::{
+    ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::{Tag, Tagged};
+
+use base64::{decode_config, encode_config};
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    pub rest: Vec<ColumnPath>,
+    pub character_set: Option<Tagged<String>>,
+    pub encode: Tagged<bool>,
+    pub decode: Tagged<bool>,
+}
+
+#[derive(Clone)]
+pub struct Base64Config {
+    pub character_set: String,
+    pub action_type: ActionType,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum ActionType {
+    Encode,
+    Decode,
+}
+pub struct SubCommand;
+
+#[async_trait]
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "hash base64"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("hash base64")
+            .named(
+                "character_set",
+                SyntaxShape::String,
+                "specify the character rules for encoding the input.\n\
+                        \tValid values are 'standard', 'standard-no-padding', 'url-safe', 'url-safe-no-padding',\
+                        'binhex', 'bcrypt', 'crypt'",
+                Some('c'),
+            )
+            .switch(
+                "encode", 
+                "encode the input as base64. This is the default behavior if not specified.", 
+                Some('e')
+            )
+            .switch(
+                "decode", 
+                "decode the input from base64", 
+                Some('d'))
+            .rest(
+                SyntaxShape::ColumnPath,
+                "optionally base64 encode / decode data by column paths",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "base64 encode or decode a value"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        operate(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Base64 encode a string with default settings",
+                example: "echo 'username:password' | hash base64",
+                result: Some(vec![
+                    UntaggedValue::string("dXNlcm5hbWU6cGFzc3dvcmQ=").into_untagged_value()
+                ]),
+            },
+            Example {
+                description: "Base64 encode a string with the binhex character set",
+                example: "echo 'username:password' | hash base64 --character_set binhex --encode",
+                result: Some(vec![
+                    UntaggedValue::string("F@0NEPjJD97kE'&bEhFZEP3").into_untagged_value()
+                ]),
+            },
+            Example {
+                description: "Base64 decode a value",
+                example: "echo 'dXNlcm5hbWU6cGFzc3dvcmQ=' | hash base64 --decode",
+                result: Some(vec![
+                    UntaggedValue::string("username:password").into_untagged_value()
+                ]),
+            },
+        ]
+    }
+}
+
+async fn operate(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_tag = &args.call_info.name_tag.clone();
+
+    let (
+        Arguments {
+            encode,
+            decode,
+            character_set,
+            rest,
+        },
+        input,
+    ) = args.process().await?;
+
+    if encode.item && decode.item {
+        return Ok(OutputStream::one(Err(ShellError::labeled_error(
+            "only one of --decode and --encode flags can be used",
+            "conflicting flags",
+            name_tag,
+        ))));
+    }
+
+    // Default the action to be encoding if no flags are specified.
+    let action_type = if *decode.item() {
+        ActionType::Decode
+    } else {
+        ActionType::Encode
+    };
+
+    // Default the character set to standard if the argument is not specified.
+    let character_set = match character_set {
+        Some(inner_tag) => inner_tag.item().to_string(),
+        None => "standard".to_string(),
+    };
+
+    let encoding_config = Base64Config {
+        character_set,
+        action_type,
+    };
+
+    let column_paths: Vec<_> = rest;
+
+    Ok(input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                ReturnSuccess::value(action(&v, &encoding_config, v.tag())?)
+            } else {
+                let mut ret = v;
+
+                for path in &column_paths {
+                    let config = encoding_config.clone();
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, &config, old.tag())),
+                    )?;
+                }
+
+                ReturnSuccess::value(ret)
+            }
+        })
+        .to_output_stream())
+}
+
+fn action(
+    input: &Value,
+    base64_config: &Base64Config,
+    tag: impl Into<Tag>,
+) -> Result<Value, ShellError> {
+    match &input.value {
+        UntaggedValue::Primitive(Primitive::String(s)) => {
+            let base64_config_enum: base64::Config = if &base64_config.character_set == "standard" {
+                base64::STANDARD
+            } else if &base64_config.character_set == "standard-no-padding" {
+                base64::STANDARD_NO_PAD
+            } else if &base64_config.character_set == "url-safe" {
+                base64::URL_SAFE
+            } else if &base64_config.character_set == "url-safe-no-padding" {
+                base64::URL_SAFE_NO_PAD
+            } else if &base64_config.character_set == "binhex" {
+                base64::BINHEX
+            } else if &base64_config.character_set == "bcrypt" {
+                base64::BCRYPT
+            } else if &base64_config.character_set == "crypt" {
+                base64::CRYPT
+            } else {
+                return Err(ShellError::labeled_error(
+                    "value is not an accepted character set",
+                    format!(
+                        "{} is not a valid character-set.\nPlease use `help hash base64` to see a list of valid character sets.", 
+                        &base64_config.character_set
+                    ),
+                    tag.into().span,
+                ));
+            };
+
+            match base64_config.action_type {
+                ActionType::Encode => Ok(UntaggedValue::string(encode_config(
+                    &s,
+                    base64_config_enum,
+                ))
+                .into_value(tag)),
+                ActionType::Decode => {
+                    let decode_result = decode_config(&s, base64_config_enum);
+
+                    match decode_result {
+                        Ok(decoded_value) => Ok(UntaggedValue::string(
+                            std::string::String::from_utf8_lossy(&decoded_value),
+                        )
+                        .into_value(tag)),
+                        Err(_) => Err(ShellError::labeled_error(
+                            "value could not be base64 decoded",
+                            format!(
+                                "invalid base64 input for character set {}",
+                                &base64_config.character_set
+                            ),
+                            tag.into().span,
+                        )),
+                    }
+                }
+            }
+        }
+        other => {
+            let got = format!("got {}", other.type_name());
+            Err(ShellError::labeled_error(
+                "value is not string",
+                got,
+                tag.into().span,
+            ))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{action, ActionType, Base64Config};
+    use nu_protocol::UntaggedValue;
+    use nu_source::Tag;
+    use nu_test_support::value::string;
+
+    #[test]
+    fn base64_encode_standard() {
+        let word = string("username:password");
+        let expected = UntaggedValue::string("dXNlcm5hbWU6cGFzc3dvcmQ=").into_untagged_value();
+
+        let actual = action(
+            &word,
+            &Base64Config {
+                character_set: "standard".to_string(),
+                action_type: ActionType::Encode,
+            },
+            Tag::unknown(),
+        )
+        .unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn base64_encode_standard_no_padding() {
+        let word = string("username:password");
+        let expected = UntaggedValue::string("dXNlcm5hbWU6cGFzc3dvcmQ").into_untagged_value();
+
+        let actual = action(
+            &word,
+            &Base64Config {
+                character_set: "standard-no-padding".to_string(),
+                action_type: ActionType::Encode,
+            },
+            Tag::unknown(),
+        )
+        .unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn base64_encode_url_safe() {
+        let word = string("this is for url");
+        let expected = UntaggedValue::string("dGhpcyBpcyBmb3IgdXJs").into_untagged_value();
+
+        let actual = action(
+            &word,
+            &Base64Config {
+                character_set: "url-safe".to_string(),
+                action_type: ActionType::Encode,
+            },
+            Tag::unknown(),
+        )
+        .unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn base64_decode_binhex() {
+        let word = string("A5\"KC9jRB@IIF'8bF!");
+        let expected = UntaggedValue::string("a binhex test").into_untagged_value();
+
+        let actual = action(
+            &word,
+            &Base64Config {
+                character_set: "binhex".to_string(),
+                action_type: ActionType::Decode,
+            },
+            Tag::unknown(),
+        )
+        .unwrap();
+        assert_eq!(actual, expected);
+    }
+}

crates/nu-command/src/commands/hash_/command.rs

@@ -0,0 +1,43 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "hash"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("hash").rest(
+            SyntaxShape::ColumnPath,
+            "optionally convert by column paths",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Apply hash function."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(get_help(&Command, &args.scope)).into_value(Tag::unknown()),
+        )))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Command;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Command {})?)
+    }
+}

crates/nu-command/src/commands/hash_/mod.rs

@@ -0,0 +1,5 @@
+mod base64_;
+mod command;
+
+pub use base64_::SubCommand as HashBase64;
+pub use command::Command as Hash;

crates/nu-command/src/commands/headers.rs

@@ -0,0 +1,119 @@
+use crate::prelude::*;
+use futures::stream::StreamExt;
+use indexmap::IndexMap;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::Dictionary;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+
+pub struct Headers;
+
+#[async_trait]
+impl WholeStreamCommand for Headers {
+    fn name(&self) -> &str {
+        "headers"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("headers")
+    }
+
+    fn usage(&self) -> &str {
+        "Use the first row of the table as column names"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        headers(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Create headers for a raw string",
+                example: r#"echo "a b c|1 2 3" | split row "|" | split column " " | headers"#,
+                result: None,
+            },
+            Example {
+                description: "Don't panic on rows with different headers",
+                example: r#"echo "a b c|1 2 3|1 2 3 4" | split row "|" | split column " " | headers"#,
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn headers(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let input = args.input;
+    let rows: Vec<Value> = input.collect().await;
+
+    if rows.is_empty() {
+        return Err(ShellError::untagged_runtime_error(
+            "Couldn't find headers, was the input a properly formatted, non-empty table?",
+        ));
+    }
+
+    //the headers are the first row in the table
+    let headers: Vec<String> = match &rows[0].value {
+        UntaggedValue::Row(d) => {
+            Ok(d.entries
+                .iter()
+                .map(|(k, v)| {
+                    match v.as_string() {
+                        Ok(s) => s,
+                        Err(_) => {
+                            //If a cell that should contain a header name is empty, we name the column Column[index]
+                            match d.entries.get_full(k) {
+                                Some((index, _, _)) => format!("Column{}", index),
+                                None => "unknownColumn".to_string(),
+                            }
+                        }
+                    }
+                })
+                .collect())
+        }
+        _ => Err(ShellError::unexpected_eof(
+            "Could not get headers, is the table empty?",
+            rows[0].tag.span,
+        )),
+    }?;
+
+    Ok(
+        futures::stream::iter(rows.into_iter().skip(1).map(move |r| {
+            //Each row is a dictionary with the headers as keys
+            match &r.value {
+                UntaggedValue::Row(d) => {
+                    let mut entries = IndexMap::new();
+                    for (i, header) in headers.iter().enumerate() {
+                        let value = match d.entries.get_index(i) {
+                            Some((_, value)) => value.clone(),
+                            None => UntaggedValue::Primitive(Primitive::Nothing).into(),
+                        };
+
+                        entries.insert(header.clone(), value);
+                    }
+                    Ok(ReturnSuccess::Value(
+                        UntaggedValue::Row(Dictionary { entries }).into_value(r.tag.clone()),
+                    ))
+                }
+                _ => Err(ShellError::unexpected_eof(
+                    "Couldn't iterate through rows, was the input a properly formatted table?",
+                    r.tag.span,
+                )),
+            }
+        }))
+        .to_output_stream(),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Headers;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Headers {})?)
+    }
+}

crates/nu-command/src/commands/help.rs

@@ -0,0 +1,222 @@
+use crate::prelude::*;
+use nu_engine::command_dict;
+use nu_engine::documentation::generate_docs;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value};
+use nu_source::{SpannedItem, Tagged};
+use nu_value_ext::ValueExt;
+
+pub struct Help;
+
+#[derive(Deserialize)]
+pub struct HelpArgs {
+    rest: Vec<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Help {
+    fn name(&self) -> &str {
+        "help"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("help").rest(SyntaxShape::String, "the name of command to get help on")
+    }
+
+    fn usage(&self) -> &str {
+        "Display help information about commands."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        help(args).await
+    }
+}
+
+async fn help(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let scope = args.scope.clone();
+    let (HelpArgs { rest }, ..) = args.process().await?;
+
+    if !rest.is_empty() {
+        if rest[0].item == "commands" {
+            let mut sorted_names = scope.get_command_names();
+            sorted_names.sort();
+
+            let (mut subcommand_names, command_names) = sorted_names
+                .into_iter()
+                // Internal only commands shouldn't be displayed
+                .filter(|cmd_name| {
+                    scope
+                        .get_command(&cmd_name)
+                        .filter(|command| !command.is_internal())
+                        .is_some()
+                })
+                .partition::<Vec<_>, _>(|cmd_name| cmd_name.contains(' '));
+
+            fn process_name(
+                dict: &mut TaggedDictBuilder,
+                cmd_name: &str,
+                scope: Scope,
+                rest: Vec<Tagged<String>>,
+                name: Tag,
+            ) -> Result<(), ShellError> {
+                let document_tag = rest[0].tag.clone();
+                let value = command_dict(
+                    scope.get_command(&cmd_name).ok_or_else(|| {
+                        ShellError::labeled_error(
+                            format!("Could not load {}", cmd_name),
+                            "could not load command",
+                            document_tag,
+                        )
+                    })?,
+                    name,
+                );
+
+                dict.insert_untagged("name", cmd_name);
+                dict.insert_untagged(
+                    "description",
+                    value
+                        .get_data_by_key("usage".spanned_unknown())
+                        .ok_or_else(|| {
+                            ShellError::labeled_error(
+                                "Expected a usage key",
+                                "expected a 'usage' key",
+                                &value.tag,
+                            )
+                        })?
+                        .as_string()?,
+                );
+
+                Ok(())
+            }
+
+            fn make_subcommands_table(
+                subcommand_names: &mut Vec<String>,
+                cmd_name: &str,
+                scope: Scope,
+                rest: Vec<Tagged<String>>,
+                name: Tag,
+            ) -> Result<Value, ShellError> {
+                let (matching, not_matching) =
+                    subcommand_names.drain(..).partition(|subcommand_name| {
+                        subcommand_name.starts_with(&format!("{} ", cmd_name))
+                    });
+                *subcommand_names = not_matching;
+                Ok(if !matching.is_empty() {
+                    UntaggedValue::table(
+                        &(matching
+                            .into_iter()
+                            .map(|cmd_name: String| -> Result<_, ShellError> {
+                                let mut short_desc = TaggedDictBuilder::new(name.clone());
+                                process_name(
+                                    &mut short_desc,
+                                    &cmd_name,
+                                    scope.clone(),
+                                    rest.clone(),
+                                    name.clone(),
+                                )?;
+                                Ok(short_desc.into_value())
+                            })
+                            .collect::<Result<Vec<_>, _>>()?[..]),
+                    )
+                    .into_value(name)
+                } else {
+                    UntaggedValue::nothing().into_value(name)
+                })
+            }
+
+            let iterator =
+                command_names
+                    .into_iter()
+                    .map(move |cmd_name| -> Result<_, ShellError> {
+                        let mut short_desc = TaggedDictBuilder::new(name.clone());
+                        process_name(
+                            &mut short_desc,
+                            &cmd_name,
+                            scope.clone(),
+                            rest.clone(),
+                            name.clone(),
+                        )?;
+                        short_desc.insert_value(
+                            "subcommands",
+                            make_subcommands_table(
+                                &mut subcommand_names,
+                                &cmd_name,
+                                scope.clone(),
+                                rest.clone(),
+                                name.clone(),
+                            )?,
+                        );
+                        ReturnSuccess::value(short_desc.into_value())
+                    });
+
+            Ok(futures::stream::iter(iterator).to_output_stream())
+        } else if rest[0].item == "generate_docs" {
+            Ok(OutputStream::one(ReturnSuccess::value(generate_docs(
+                &scope,
+            ))))
+        } else if rest.len() == 2 {
+            // Check for a subcommand
+            let command_name = format!("{} {}", rest[0].item, rest[1].item);
+            if let Some(command) = scope.get_command(&command_name) {
+                Ok(OutputStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(get_help(command.stream_command(), &scope))
+                        .into_value(Tag::unknown()),
+                )))
+            } else {
+                Ok(OutputStream::empty())
+            }
+        } else if let Some(command) = scope.get_command(&rest[0].item) {
+            Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(get_help(command.stream_command(), &scope))
+                    .into_value(Tag::unknown()),
+            )))
+        } else {
+            Err(ShellError::labeled_error(
+                "Can't find command (use 'help commands' for full list)",
+                "can't find command",
+                rest[0].tag.span,
+            ))
+        }
+    } else {
+        let msg = r#"Welcome to Nushell.
+
+Here are some tips to help you get started.
+  * help commands - list all available commands
+  * help <command name> - display help about a particular command
+
+Nushell works on the idea of a "pipeline". Pipelines are commands connected with the '|' character.
+Each stage in the pipeline works together to load, parse, and display information to you.
+
+[Examples]
+
+List the files in the current directory, sorted by size:
+    ls | sort-by size
+
+Get information about the current system:
+    sys | get host
+
+Get the processes on your system actively using CPU:
+    ps | where cpu > 0
+
+You can also learn more at https://www.nushell.sh/book/"#;
+
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(msg).into_value(Tag::unknown()),
+        )))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Help;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Help {})?)
+    }
+}

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

@@ -0,0 +1,230 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    ColumnPath, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+
+pub struct Histogram;
+
+#[async_trait]
+impl WholeStreamCommand for Histogram {
+    fn name(&self) -> &str {
+        "histogram"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("histogram")
+            .named(
+                "use",
+                SyntaxShape::ColumnPath,
+                "Use data at the column path given as valuator",
+                None,
+            )
+            .rest(
+                SyntaxShape::ColumnPath,
+                "column name to give the histogram's frequency column",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Creates a new table with a histogram based on the column name passed in."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        histogram(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get a histogram for the types of files",
+                example: "ls | histogram type",
+                result: None,
+            },
+            Example {
+                description:
+                    "Get a histogram for the types of files, with frequency column named percentage",
+                example: "ls | histogram type percentage",
+                result: None,
+            },
+            Example {
+                description: "Get a histogram for a list of numbers",
+                example: "echo [1 2 3 1 1 1 2 2 1 1] | histogram",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn histogram(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let (input, args) = args.evaluate_once().await?.parts();
+
+    let values: Vec<Value> = input.collect().await;
+
+    let mut columns = args
+        .positional_iter()
+        .map(|c| c.as_column_path())
+        .filter_map(Result::ok)
+        .collect::<Vec<_>>();
+
+    let evaluate_with = if let Some(path) = args.get("use") {
+        Some(evaluator(path.as_column_path()?.item))
+    } else {
+        None
+    };
+
+    let column_grouper = if !columns.is_empty() {
+        match columns.remove(0).split_last() {
+            Some((key, _)) => Some(key.as_string().tagged(&name)),
+            None => None,
+        }
+    } else {
+        None
+    };
+
+    let frequency_column_name = if columns.is_empty() {
+        "frequency".to_string()
+    } else if let Some((key, _)) = columns[0].split_last() {
+        key.as_string()
+    } else {
+        "frequency".to_string()
+    };
+
+    let column = if let Some(ref column) = column_grouper {
+        column.clone()
+    } else {
+        "value".to_string().tagged(&name)
+    };
+
+    let results = nu_data::utils::report(
+        &UntaggedValue::table(&values).into_value(&name),
+        nu_data::utils::Operation {
+            grouper: Some(Box::new(move |_, _| Ok(String::from("frequencies")))),
+            splitter: Some(splitter(column_grouper)),
+            format: &None,
+            eval: &evaluate_with,
+            reduction: &nu_data::utils::Reduction::Count,
+        },
+        &name,
+    )?;
+
+    let labels = results.labels.y.clone();
+    let mut idx = 0;
+
+    Ok(futures::stream::iter(
+        results
+            .data
+            .table_entries()
+            .cloned()
+            .collect::<Vec<_>>()
+            .into_iter()
+            .zip(
+                results
+                    .percentages
+                    .table_entries()
+                    .cloned()
+                    .collect::<Vec<_>>()
+                    .into_iter(),
+            )
+            .map(move |(counts, percentages)| {
+                let percentage = percentages
+                    .table_entries()
+                    .cloned()
+                    .last()
+                    .unwrap_or_else(|| {
+                        UntaggedValue::decimal_from_float(0.0, name.span).into_value(&name)
+                    });
+                let value = counts
+                    .table_entries()
+                    .cloned()
+                    .last()
+                    .unwrap_or_else(|| UntaggedValue::int(0).into_value(&name));
+
+                let mut fact = TaggedDictBuilder::new(&name);
+                let column_value = labels
+                    .get(idx)
+                    .ok_or_else(|| {
+                        ShellError::labeled_error(
+                            "Unable to load group labels",
+                            "unable to load group labels",
+                            &name,
+                        )
+                    })?
+                    .clone();
+
+                fact.insert_value(&column.item, column_value);
+                fact.insert_untagged("count", value);
+
+                let fmt_percentage = format!(
+                    "{}%",
+                    // Some(2) < the number of digits
+                    // true < group the digits
+                    crate::commands::str_::from::action(&percentage, &name, Some(2), true)?
+                        .as_string()?
+                );
+                fact.insert_untagged("percentage", UntaggedValue::string(fmt_percentage));
+
+                let string = std::iter::repeat("*")
+                    .take(percentage.as_u64().map_err(|_| {
+                        ShellError::labeled_error("expected a number", "expected a number", &name)
+                    })? as usize)
+                    .collect::<String>();
+
+                fact.insert_untagged(&frequency_column_name, UntaggedValue::string(string));
+
+                idx += 1;
+
+                ReturnSuccess::value(fact.into_value())
+            }),
+    )
+    .to_output_stream())
+}
+
+fn evaluator(by: ColumnPath) -> Box<dyn Fn(usize, &Value) -> Result<Value, ShellError> + Send> {
+    Box::new(move |_: usize, value: &Value| {
+        let path = by.clone();
+
+        let eval = nu_value_ext::get_data_by_column_path(value, &path, move |_, _, error| error);
+
+        match eval {
+            Ok(with_value) => Ok(with_value),
+            Err(reason) => Err(reason),
+        }
+    })
+}
+
+fn splitter(
+    by: Option<Tagged<String>>,
+) -> Box<dyn Fn(usize, &Value) -> Result<String, ShellError> + Send> {
+    match by {
+        Some(column) => Box::new(move |_, row: &Value| {
+            let key = &column;
+
+            match row.get_data_by_key(key.borrow_spanned()) {
+                Some(key) => nu_value_ext::as_string(&key),
+                None => Err(ShellError::labeled_error(
+                    "unknown column",
+                    "unknown column",
+                    key.tag(),
+                )),
+            }
+        }),
+        None => Box::new(move |_, row: &Value| nu_value_ext::as_string(&row)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Histogram;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Histogram {})?)
+    }
+}

crates/nu-command/src/commands/history.rs

@@ -0,0 +1,82 @@
+use crate::prelude::*;
+use nu_data::config::{Conf, NuConfig};
+use nu_engine::history_path;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+
+#[derive(Deserialize)]
+struct Arguments {
+    clear: Option<bool>,
+}
+
+pub struct History;
+
+#[async_trait]
+impl WholeStreamCommand for History {
+    fn name(&self) -> &str {
+        "history"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("history").switch("clear", "Clears out the history entries", Some('c'))
+    }
+
+    fn usage(&self) -> &str {
+        "Display command history."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        history(args).await
+    }
+}
+
+async fn history(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let config: Box<dyn Conf> = Box::new(NuConfig::new());
+    let tag = args.call_info.name_tag.clone();
+    let (Arguments { clear }, _) = args.process().await?;
+
+    let path = history_path(&config);
+
+    match clear {
+        Some(_) => {
+            // This is a NOOP, the logic to clear is handled in cli.rs
+            Ok(OutputStream::empty())
+        }
+        None => {
+            if let Ok(file) = File::open(path) {
+                let reader = BufReader::new(file);
+                // Skips the first line, which is a Rustyline internal
+                let output = reader.lines().skip(1).filter_map(move |line| match line {
+                    Ok(line) => Some(ReturnSuccess::value(
+                        UntaggedValue::string(line).into_value(tag.clone()),
+                    )),
+                    Err(_) => None,
+                });
+
+                Ok(futures::stream::iter(output).to_output_stream())
+            } else {
+                Err(ShellError::labeled_error(
+                    "Could not open history",
+                    "history file could not be opened",
+                    tag,
+                ))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::History;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(History {})?)
+    }
+}

crates/nu-command/src/commands/if_.rs

@@ -0,0 +1,142 @@
+use crate::prelude::*;
+use nu_engine::evaluate_baseline_expr;
+use nu_engine::run_block;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::CapturedBlock, hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue,
+};
+
+pub struct If;
+
+#[derive(Deserialize)]
+pub struct IfArgs {
+    condition: CapturedBlock,
+    then_case: CapturedBlock,
+    else_case: CapturedBlock,
+}
+
+#[async_trait]
+impl WholeStreamCommand for If {
+    fn name(&self) -> &str {
+        "if"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("if")
+            .required(
+                "condition",
+                SyntaxShape::MathExpression,
+                "the condition that must match",
+            )
+            .required(
+                "then_case",
+                SyntaxShape::Block,
+                "block to run if condition is true",
+            )
+            .required(
+                "else_case",
+                SyntaxShape::Block,
+                "block to run if condition is false",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Run blocks if a condition is true or false."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        if_command(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Run a block if a condition is true",
+                example: "let x = 10; if $x > 5 { echo 'greater than 5' } { echo 'less than or equal to 5' }",
+                result: Some(vec![UntaggedValue::string("greater than 5").into()]),
+            },
+            Example {
+                description: "Run a block if a condition is false",
+                example: "let x = 1; if $x > 5 { echo 'greater than 5' } { echo 'less than or equal to 5' }",
+                result: Some(vec![UntaggedValue::string("less than or equal to 5").into()]),
+            },
+        ]
+    }
+}
+async fn if_command(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = raw_args.call_info.name_tag.clone();
+    let context = Arc::new(EvaluationContext::from_raw(&raw_args));
+
+    let (
+        IfArgs {
+            condition,
+            then_case,
+            else_case,
+        },
+        input,
+    ) = raw_args.process().await?;
+    let cond = {
+        if condition.block.block.len() != 1 {
+            return Err(ShellError::labeled_error(
+                "Expected a condition",
+                "expected a condition",
+                tag,
+            ));
+        }
+        match condition.block.block[0].pipelines.get(0) {
+            Some(item) => match item.list.get(0) {
+                Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
+                _ => {
+                    return Err(ShellError::labeled_error(
+                        "Expected a condition",
+                        "expected a condition",
+                        tag,
+                    ));
+                }
+            },
+            None => {
+                return Err(ShellError::labeled_error(
+                    "Expected a condition",
+                    "expected a condition",
+                    tag,
+                ));
+            }
+        }
+    };
+
+    context.scope.enter_scope();
+    context.scope.add_vars(&condition.captured.entries);
+
+    //FIXME: should we use the scope that's brought in as well?
+    let condition = evaluate_baseline_expr(&cond, &*context).await;
+    match condition {
+        Ok(condition) => match condition.as_bool() {
+            Ok(b) => {
+                let result = if b {
+                    run_block(&then_case.block, &*context, input).await
+                } else {
+                    run_block(&else_case.block, &*context, input).await
+                };
+                context.scope.exit_scope();
+
+                result.map(|x| x.to_output_stream())
+            }
+            Err(e) => Ok(futures::stream::iter(vec![Err(e)].into_iter()).to_output_stream()),
+        },
+        Err(e) => Ok(futures::stream::iter(vec![Err(e)].into_iter()).to_output_stream()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::If;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(If {})?)
+    }
+}

crates/nu-command/src/commands/insert.rs

@@ -0,0 +1,177 @@
+use crate::prelude::*;
+use nu_engine::run_block;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_value_ext::ValueExt;
+
+use futures::stream::once;
+
+pub struct Command;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    column: ColumnPath,
+    value: Value,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "insert"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("insert")
+            .required(
+                "column",
+                SyntaxShape::ColumnPath,
+                "the column name to insert",
+            )
+            .required("value", SyntaxShape::Any, "the value to give the cell(s)")
+    }
+
+    fn usage(&self) -> &str {
+        "Insert a new column with a given value."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        insert(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Insert a column with a value",
+            example: "echo [[author, commits]; ['Andrés', 1]] | insert branches 5",
+            result: Some(vec![UntaggedValue::row(indexmap! {
+                    "author".to_string() => Value::from("Andrés"),
+                    "commits".to_string() => UntaggedValue::int(1).into(),
+                    "branches".to_string() => UntaggedValue::int(5).into(),
+            })
+            .into()]),
+        },Example {
+            description: "Use in block form for more involved insertion logic",
+            example: "echo [[author, lucky_number]; ['Yehuda', 4]] | insert success { = $it.lucky_number * 10 }",
+            result: Some(vec![UntaggedValue::row(indexmap! {
+                    "author".to_string() => Value::from("Yehuda"),
+                    "lucky_number".to_string() => UntaggedValue::int(4).into(),
+                    "success".to_string() => UntaggedValue::int(40).into(),
+            })
+            .into()]),
+        }]
+    }
+}
+
+async fn process_row(
+    context: Arc<EvaluationContext>,
+    input: Value,
+    mut value: Arc<Value>,
+    field: Arc<ColumnPath>,
+) -> Result<OutputStream, ShellError> {
+    let value = Arc::make_mut(&mut value);
+
+    Ok(match value {
+        Value {
+            value: UntaggedValue::Block(block),
+            tag: block_tag,
+        } => {
+            let for_block = input.clone();
+            let input_stream = once(async { Ok(for_block) }).to_input_stream();
+
+            context.scope.enter_scope();
+            context.scope.add_vars(&block.captured.entries);
+            context.scope.add_var("$it", input.clone());
+
+            let result = run_block(&block.block, &*context, input_stream).await;
+
+            context.scope.exit_scope();
+
+            match result {
+                Ok(mut stream) => {
+                    let values = stream.drain_vec().await;
+
+                    let errors = context.get_errors();
+                    if let Some(error) = errors.first() {
+                        return Err(error.clone());
+                    }
+
+                    let result = if values.len() == 1 {
+                        let value = values
+                            .get(0)
+                            .ok_or_else(|| ShellError::unexpected("No value to insert with."))?;
+
+                        Value {
+                            value: value.value.clone(),
+                            tag: input.tag.clone(),
+                        }
+                    } else if values.is_empty() {
+                        UntaggedValue::nothing().into_value(&input.tag)
+                    } else {
+                        UntaggedValue::table(&values).into_value(&input.tag)
+                    };
+
+                    match input {
+                        obj
+                        @
+                        Value {
+                            value: UntaggedValue::Row(_),
+                            ..
+                        } => match obj.insert_data_at_column_path(&field, result) {
+                            Ok(v) => OutputStream::one(ReturnSuccess::value(v)),
+                            Err(e) => OutputStream::one(Err(e)),
+                        },
+                        _ => OutputStream::one(Err(ShellError::labeled_error(
+                            "Unrecognized type in stream",
+                            "original value",
+                            block_tag.clone(),
+                        ))),
+                    }
+                }
+                Err(e) => OutputStream::one(Err(e)),
+            }
+        }
+        value => match input {
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Nothing),
+                ..
+            } => match context
+                .scope
+                .get_var("$it")
+                .unwrap_or_else(|| UntaggedValue::nothing().into_untagged_value())
+                .insert_data_at_column_path(&field, value.clone())
+            {
+                Ok(v) => OutputStream::one(ReturnSuccess::value(v)),
+                Err(e) => OutputStream::one(Err(e)),
+            },
+            _ => match input.insert_data_at_column_path(&field, value.clone()) {
+                Ok(v) => OutputStream::one(ReturnSuccess::value(v)),
+                Err(e) => OutputStream::one(Err(e)),
+            },
+        },
+    })
+}
+
+async fn insert(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let context = Arc::new(EvaluationContext::from_raw(&raw_args));
+    let (Arguments { column, value }, input) = raw_args.process().await?;
+    let value = Arc::new(value);
+    let column = Arc::new(column);
+
+    Ok(input
+        .then(move |input| {
+            let context = context.clone();
+            let value = value.clone();
+            let column = column.clone();
+
+            async {
+                match process_row(context, input, value, column).await {
+                    Ok(s) => s,
+                    Err(e) => OutputStream::one(Err(e)),
+                }
+            }
+        })
+        .flatten()
+        .to_output_stream())
+}

crates/nu-command/src/commands/into_int.rs

@@ -0,0 +1,81 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+
+use num_bigint::ToBigInt;
+
+pub struct IntoInt;
+
+#[derive(Deserialize)]
+pub struct IntoIntArgs {
+    pub rest: Vec<Value>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for IntoInt {
+    fn name(&self) -> &str {
+        "into-int"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into-int").rest(SyntaxShape::Any, "the values to into-int")
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to integer"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_int(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Convert filesize to integer",
+            example: "into-int 1kb | each { = $it / 1024 }",
+            result: Some(vec![UntaggedValue::int(1).into()]),
+        }]
+    }
+}
+
+async fn into_int(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (args, _): (IntoIntArgs, _) = args.process().await?;
+
+    let stream = args.rest.into_iter().map(|i| match i {
+        Value {
+            value: UntaggedValue::Primitive(primitive_val),
+            tag,
+        } => match primitive_val {
+            Primitive::Filesize(size) => OutputStream::one(Ok(ReturnSuccess::Value(Value {
+                value: UntaggedValue::int(size.to_bigint().expect("Conversion should never fail.")),
+                tag,
+            }))),
+            Primitive::Int(_) => OutputStream::one(Ok(ReturnSuccess::Value(Value {
+                value: UntaggedValue::Primitive(primitive_val),
+                tag,
+            }))),
+            _ => OutputStream::one(Err(ShellError::labeled_error(
+                "Could not convert int value",
+                "original value",
+                tag,
+            ))),
+        },
+        _ => OutputStream::one(Ok(ReturnSuccess::Value(i))),
+    });
+
+    Ok(futures::stream::iter(stream).flatten().to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::IntoInt;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(IntoInt {})?)
+    }
+}

crates/nu-command/src/commands/keep/command.rs

@@ -0,0 +1,79 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+
+pub struct Command;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    rows: Option<Tagged<usize>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "keep"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("keep").optional(
+            "rows",
+            SyntaxShape::Int,
+            "Starting from the front, the number of rows to keep",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Keep the number of rows only"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        keep(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Keep the first row",
+                example: "echo [1 2 3] | keep",
+                result: Some(vec![UntaggedValue::int(1).into()]),
+            },
+            Example {
+                description: "Keep the first four rows",
+                example: "echo [1 2 3 4 5] | keep 4",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(2).into(),
+                    UntaggedValue::int(3).into(),
+                    UntaggedValue::int(4).into(),
+                ]),
+            },
+        ]
+    }
+}
+
+async fn keep(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (Arguments { rows }, input) = args.process().await?;
+    let rows_desired = if let Some(quantity) = rows {
+        *quantity
+    } else {
+        1
+    };
+
+    Ok(input.take(rows_desired).to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Command;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Command {})?)
+    }
+}