Move repl loop and command/script execution to nu_cli (#4846)

* Refactor usage of is_perf_true to be a parameter passed around

* Move repl loop and command/script execution to nu_cli

* Move config setup out of nu_cli

* Update config_files.rs

* Update main.rs

Co-authored-by: JT <547158+jntrnr@users.noreply.github.com>

crates/nu-cli/src/commands.rs

@@ -0,0 +1,103 @@
+use crate::util::report_error;
+use log::info;
+use miette::Result;
+use nu_engine::{convert_env_values, eval_block};
+use nu_parser::{parse, trim_quotes};
+use nu_protocol::engine::Stack;
+use nu_protocol::{
+    engine::{EngineState, StateDelta, StateWorkingSet},
+    Config, PipelineData, Spanned,
+};
+use std::path::Path;
+
+pub fn evaluate_commands(
+    commands: &Spanned<String>,
+    init_cwd: &Path,
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    input: PipelineData,
+    is_perf_true: bool,
+) -> Result<()> {
+    // Run a command (or commands) given to us by the user
+    let (block, delta) = {
+        let mut working_set = StateWorkingSet::new(engine_state);
+
+        let (input, _) = if commands.item.starts_with('\'') || commands.item.starts_with('"') {
+            (
+                trim_quotes(commands.item.as_bytes()),
+                commands.span.start + 1,
+            )
+        } else {
+            (commands.item.as_bytes(), commands.span.start)
+        };
+
+        let (output, err) = parse(&mut working_set, None, input, false);
+        if let Some(err) = err {
+            report_error(&working_set, &err);
+
+            std::process::exit(1);
+        }
+
+        (output, working_set.render())
+    };
+
+    if let Err(err) = engine_state.merge_delta(delta, None, init_cwd) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &err);
+    }
+
+    let config = match stack.get_config() {
+        Ok(config) => config,
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &e);
+            Config::default()
+        }
+    };
+
+    // Make a note of the exceptions we see for externals that look like math expressions
+    let exceptions = crate::util::external_exceptions(engine_state, stack);
+    engine_state.external_exceptions = exceptions;
+
+    // Merge the delta in case env vars changed in the config
+    match nu_engine::env::current_dir(engine_state, stack) {
+        Ok(cwd) => {
+            if let Err(e) = engine_state.merge_delta(StateDelta::new(), Some(stack), cwd) {
+                let working_set = StateWorkingSet::new(engine_state);
+                report_error(&working_set, &e);
+                std::process::exit(1);
+            }
+        }
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
+            std::process::exit(1);
+        }
+    }
+
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+        std::process::exit(1);
+    }
+
+    match eval_block(engine_state, stack, &block, input, false, false) {
+        Ok(pipeline_data) => {
+            crate::eval_file::print_table_or_error(engine_state, stack, pipeline_data, &config)
+        }
+        Err(err) => {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &err);
+            std::process::exit(1);
+        }
+    }
+
+    if is_perf_true {
+        info!("evaluate {}:{}:{}", file!(), line!(), column!());
+    }
+
+    Ok(())
+}

crates/nu-cli/src/config_files.rs

@@ -0,0 +1,84 @@
+use crate::util::{eval_source, report_error};
+#[cfg(feature = "plugin")]
+use log::info;
+use nu_protocol::engine::{EngineState, Stack, StateDelta, StateWorkingSet};
+use nu_protocol::{PipelineData, Span};
+use std::path::PathBuf;
+
+#[cfg(feature = "plugin")]
+const PLUGIN_FILE: &str = "plugin.nu";
+
+#[cfg(feature = "plugin")]
+pub fn read_plugin_file(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    storage_path: &str,
+    is_perf_true: bool,
+) {
+    // Reading signatures from signature file
+    // The plugin.nu file stores the parsed signature collected from each registered plugin
+    add_plugin_file(engine_state, storage_path);
+
+    let plugin_path = engine_state.plugin_signatures.clone();
+    if let Some(plugin_path) = plugin_path {
+        let plugin_filename = plugin_path.to_string_lossy().to_owned();
+
+        if let Ok(contents) = std::fs::read(&plugin_path) {
+            eval_source(
+                engine_state,
+                stack,
+                &contents,
+                &plugin_filename,
+                PipelineData::new(Span::new(0, 0)),
+            );
+        }
+    }
+
+    if is_perf_true {
+        info!("read_plugin_file {}:{}:{}", file!(), line!(), column!());
+    }
+}
+
+#[cfg(feature = "plugin")]
+pub fn add_plugin_file(engine_state: &mut EngineState, storage_path: &str) {
+    if let Some(mut plugin_path) = nu_path::config_dir() {
+        // Path to store plugins signatures
+        plugin_path.push(storage_path);
+        plugin_path.push(PLUGIN_FILE);
+        engine_state.plugin_signatures = Some(plugin_path.clone());
+    }
+}
+
+pub fn eval_config_contents(
+    config_path: PathBuf,
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+) {
+    if config_path.exists() & config_path.is_file() {
+        let config_filename = config_path.to_string_lossy().to_owned();
+
+        if let Ok(contents) = std::fs::read(&config_path) {
+            eval_source(
+                engine_state,
+                stack,
+                &contents,
+                &config_filename,
+                PipelineData::new(Span::new(0, 0)),
+            );
+
+            // Merge the delta in case env vars changed in the config
+            match nu_engine::env::current_dir(engine_state, stack) {
+                Ok(cwd) => {
+                    if let Err(e) = engine_state.merge_delta(StateDelta::new(), Some(stack), cwd) {
+                        let working_set = StateWorkingSet::new(engine_state);
+                        report_error(&working_set, &e);
+                    }
+                }
+                Err(e) => {
+                    let working_set = StateWorkingSet::new(engine_state);
+                    report_error(&working_set, &e);
+                }
+            }
+        }
+    }
+}

crates/nu-cli/src/eval_file.rs

@@ -0,0 +1,145 @@
+use crate::util::{eval_source, report_error};
+use log::info;
+use log::trace;
+use miette::{IntoDiagnostic, Result};
+use nu_engine::convert_env_values;
+use nu_parser::parse;
+use nu_protocol::{
+    ast::Call,
+    engine::{EngineState, Stack, StateWorkingSet},
+    Config, PipelineData, Span, Value,
+};
+use std::io::Write;
+
+/// Main function used when a file path is found as argument for nu
+pub fn evaluate_file(
+    path: String,
+    args: &[String],
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    input: PipelineData,
+    is_perf_true: bool,
+) -> Result<()> {
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+        std::process::exit(1);
+    }
+
+    // Make a note of the exceptions we see for externals that look like math expressions
+    let exceptions = crate::util::external_exceptions(engine_state, stack);
+    engine_state.external_exceptions = exceptions;
+
+    let file = std::fs::read(&path).into_diagnostic()?;
+
+    let mut working_set = StateWorkingSet::new(engine_state);
+    trace!("parsing file: {}", path);
+
+    let _ = parse(&mut working_set, Some(&path), &file, false);
+
+    if working_set.find_decl(b"main").is_some() {
+        let args = format!("main {}", args.join(" "));
+
+        if !eval_source(
+            engine_state,
+            stack,
+            &file,
+            &path,
+            PipelineData::new(Span::new(0, 0)),
+        ) {
+            std::process::exit(1);
+        }
+        if !eval_source(engine_state, stack, args.as_bytes(), "<commandline>", input) {
+            std::process::exit(1);
+        }
+    } else if !eval_source(engine_state, stack, &file, &path, input) {
+        std::process::exit(1);
+    }
+
+    if is_perf_true {
+        info!("evaluate {}:{}:{}", file!(), line!(), column!());
+    }
+
+    Ok(())
+}
+
+pub fn print_table_or_error(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    mut pipeline_data: PipelineData,
+    config: &Config,
+) {
+    let exit_code = match &mut pipeline_data {
+        PipelineData::ExternalStream { exit_code, .. } => exit_code.take(),
+        _ => None,
+    };
+
+    match engine_state.find_decl("table".as_bytes()) {
+        Some(decl_id) => {
+            let table = engine_state.get_decl(decl_id).run(
+                engine_state,
+                stack,
+                &Call::new(Span::new(0, 0)),
+                pipeline_data,
+            );
+
+            match table {
+                Ok(table) => {
+                    for item in table {
+                        let stdout = std::io::stdout();
+
+                        if let Value::Error { error } = item {
+                            let working_set = StateWorkingSet::new(engine_state);
+
+                            report_error(&working_set, &error);
+
+                            std::process::exit(1);
+                        }
+
+                        let mut out = item.into_string("\n", config);
+                        out.push('\n');
+
+                        match stdout.lock().write_all(out.as_bytes()) {
+                            Ok(_) => (),
+                            Err(err) => eprintln!("{}", err),
+                        };
+                    }
+                }
+                Err(error) => {
+                    let working_set = StateWorkingSet::new(engine_state);
+
+                    report_error(&working_set, &error);
+
+                    std::process::exit(1);
+                }
+            }
+        }
+        None => {
+            for item in pipeline_data {
+                let stdout = std::io::stdout();
+
+                if let Value::Error { error } = item {
+                    let working_set = StateWorkingSet::new(engine_state);
+
+                    report_error(&working_set, &error);
+
+                    std::process::exit(1);
+                }
+
+                let mut out = item.into_string("\n", config);
+                out.push('\n');
+
+                match stdout.lock().write_all(out.as_bytes()) {
+                    Ok(_) => (),
+                    Err(err) => eprintln!("{}", err),
+                };
+            }
+        }
+    };
+
+    // Make sure everything has finished
+    if let Some(exit_code) = exit_code {
+        let _: Vec<_> = exit_code.into_iter().collect();
+    }
+}

crates/nu-cli/src/lib.rs

@@ -1,17 +1,33 @@
+mod commands;
 mod completions;
+mod config_files;
 mod errors;
+mod eval_file;
 mod nu_highlight;
 mod print;
 mod prompt;
+mod prompt_update;
+mod reedline_config;
+mod repl;
 mod syntax_highlight;
 mod util;
 mod validation;
 
+pub use commands::evaluate_commands;
 pub use completions::NuCompleter;
+pub use config_files::eval_config_contents;
 pub use errors::CliError;
+pub use eval_file::evaluate_file;
 pub use nu_highlight::NuHighlight;
 pub use print::Print;
 pub use prompt::NushellPrompt;
+pub use repl::evaluate_repl;
 pub use syntax_highlight::NuHighlighter;
 pub use util::print_pipeline_data;
+pub use util::{eval_source, gather_parent_env_vars, get_init_cwd, report_error};
 pub use validation::NuValidator;
+
+#[cfg(feature = "plugin")]
+pub use config_files::add_plugin_file;
+#[cfg(feature = "plugin")]
+pub use config_files::read_plugin_file;

crates/nu-cli/src/prompt_update.rs

@@ -0,0 +1,193 @@
+use crate::util::report_error;
+use crate::NushellPrompt;
+use log::info;
+use nu_engine::eval_subexpression;
+use nu_parser::parse;
+use nu_protocol::{
+    engine::{EngineState, Stack, StateWorkingSet},
+    Config, PipelineData, Span, Value,
+};
+use reedline::Prompt;
+
+// Name of environment variable where the prompt could be stored
+pub(crate) const PROMPT_COMMAND: &str = "PROMPT_COMMAND";
+pub(crate) const PROMPT_COMMAND_RIGHT: &str = "PROMPT_COMMAND_RIGHT";
+pub(crate) const PROMPT_INDICATOR: &str = "PROMPT_INDICATOR";
+pub(crate) const PROMPT_INDICATOR_VI_INSERT: &str = "PROMPT_INDICATOR_VI_INSERT";
+pub(crate) const PROMPT_INDICATOR_VI_NORMAL: &str = "PROMPT_INDICATOR_VI_NORMAL";
+pub(crate) const PROMPT_MULTILINE_INDICATOR: &str = "PROMPT_MULTILINE_INDICATOR";
+
+pub(crate) fn get_prompt_indicators(
+    config: &Config,
+    engine_state: &EngineState,
+    stack: &Stack,
+    is_perf_true: bool,
+) -> (String, String, String, String) {
+    let prompt_indicator = match stack.get_env_var(engine_state, PROMPT_INDICATOR) {
+        Some(pi) => pi.into_string("", config),
+        None => "〉".to_string(),
+    };
+
+    let prompt_vi_insert = match stack.get_env_var(engine_state, PROMPT_INDICATOR_VI_INSERT) {
+        Some(pvii) => pvii.into_string("", config),
+        None => ": ".to_string(),
+    };
+
+    let prompt_vi_normal = match stack.get_env_var(engine_state, PROMPT_INDICATOR_VI_NORMAL) {
+        Some(pviv) => pviv.into_string("", config),
+        None => "〉".to_string(),
+    };
+
+    let prompt_multiline = match stack.get_env_var(engine_state, PROMPT_MULTILINE_INDICATOR) {
+        Some(pm) => pm.into_string("", config),
+        None => "::: ".to_string(),
+    };
+
+    if is_perf_true {
+        info!(
+            "get_prompt_indicators {}:{}:{}",
+            file!(),
+            line!(),
+            column!()
+        );
+    }
+
+    (
+        prompt_indicator,
+        prompt_vi_insert,
+        prompt_vi_normal,
+        prompt_multiline,
+    )
+}
+
+fn get_prompt_string(
+    prompt: &str,
+    config: &Config,
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    is_perf_true: bool,
+) -> Option<String> {
+    stack
+        .get_env_var(engine_state, prompt)
+        .and_then(|v| match v {
+            Value::Block {
+                val: block_id,
+                captures,
+                ..
+            } => {
+                let block = engine_state.get_block(block_id);
+                let mut stack = stack.captures_to_stack(&captures);
+                // Use eval_subexpression to force a redirection of output, so we can use everything in prompt
+                let ret_val = eval_subexpression(
+                    engine_state,
+                    &mut stack,
+                    block,
+                    PipelineData::new(Span::new(0, 0)), // Don't try this at home, 0 span is ignored
+                );
+                if is_perf_true {
+                    info!(
+                        "get_prompt_string (block) {}:{}:{}",
+                        file!(),
+                        line!(),
+                        column!()
+                    );
+                }
+
+                match ret_val {
+                    Ok(ret_val) => Some(ret_val),
+                    Err(err) => {
+                        let working_set = StateWorkingSet::new(engine_state);
+                        report_error(&working_set, &err);
+                        None
+                    }
+                }
+            }
+            Value::String { val: source, .. } => {
+                let mut working_set = StateWorkingSet::new(engine_state);
+                let (block, _) = parse(&mut working_set, None, source.as_bytes(), true);
+                // Use eval_subexpression to force a redirection of output, so we can use everything in prompt
+                let ret_val = eval_subexpression(
+                    engine_state,
+                    stack,
+                    &block,
+                    PipelineData::new(Span::new(0, 0)), // Don't try this at home, 0 span is ignored
+                )
+                .ok();
+                if is_perf_true {
+                    info!(
+                        "get_prompt_string (string) {}:{}:{}",
+                        file!(),
+                        line!(),
+                        column!()
+                    );
+                }
+
+                ret_val
+            }
+            _ => None,
+        })
+        .and_then(|pipeline_data| {
+            let output = pipeline_data.collect_string("", config).ok();
+
+            match output {
+                Some(mut x) => {
+                    // Just remove the very last newline.
+                    if x.ends_with('\n') {
+                        x.pop();
+                    }
+
+                    if x.ends_with('\r') {
+                        x.pop();
+                    }
+                    Some(x)
+                }
+                None => None,
+            }
+        })
+}
+
+pub(crate) fn update_prompt<'prompt>(
+    config: &Config,
+    engine_state: &EngineState,
+    stack: &Stack,
+    nu_prompt: &'prompt mut NushellPrompt,
+    is_perf_true: bool,
+) -> &'prompt dyn Prompt {
+    // get the other indicators
+    let (
+        prompt_indicator_string,
+        prompt_vi_insert_string,
+        prompt_vi_normal_string,
+        prompt_multiline_string,
+    ) = get_prompt_indicators(config, engine_state, stack, is_perf_true);
+
+    let mut stack = stack.clone();
+
+    // apply the other indicators
+    nu_prompt.update_all_prompt_strings(
+        get_prompt_string(
+            PROMPT_COMMAND,
+            config,
+            engine_state,
+            &mut stack,
+            is_perf_true,
+        ),
+        get_prompt_string(
+            PROMPT_COMMAND_RIGHT,
+            config,
+            engine_state,
+            &mut stack,
+            is_perf_true,
+        ),
+        prompt_indicator_string,
+        prompt_multiline_string,
+        (prompt_vi_insert_string, prompt_vi_normal_string),
+    );
+
+    let ret_val = nu_prompt as &dyn Prompt;
+    if is_perf_true {
+        info!("update_prompt {}:{}:{}", file!(), line!(), column!());
+    }
+
+    ret_val
+}

crates/nu-cli/src/reedline_config.rs

@@ -0,0 +1,781 @@
+use crossterm::event::{KeyCode, KeyModifiers};
+use nu_color_config::lookup_ansi_color_style;
+use nu_protocol::{extract_value, Config, ParsedKeybinding, ShellError, Span, Value};
+use reedline::{
+    default_emacs_keybindings, default_vi_insert_keybindings, default_vi_normal_keybindings,
+    CompletionMenu, EditCommand, HistoryMenu, Keybindings, Reedline, ReedlineEvent,
+};
+
+// Creates an input object for the completion menu based on the dictionary
+// stored in the config variable
+pub(crate) fn add_completion_menu(line_editor: Reedline, config: &Config) -> Reedline {
+    let mut completion_menu = CompletionMenu::default();
+
+    completion_menu = match config
+        .menu_config
+        .get("columns")
+        .and_then(|value| value.as_integer().ok())
+    {
+        Some(value) => completion_menu.with_columns(value as u16),
+        None => completion_menu,
+    };
+
+    completion_menu = completion_menu.with_column_width(
+        config
+            .menu_config
+            .get("col_width")
+            .and_then(|value| value.as_integer().ok())
+            .map(|value| value as usize),
+    );
+
+    completion_menu = match config
+        .menu_config
+        .get("col_padding")
+        .and_then(|value| value.as_integer().ok())
+    {
+        Some(value) => completion_menu.with_column_padding(value as usize),
+        None => completion_menu,
+    };
+
+    completion_menu = match config
+        .menu_config
+        .get("text_style")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => completion_menu.with_text_style(lookup_ansi_color_style(&value)),
+        None => completion_menu,
+    };
+
+    completion_menu = match config
+        .menu_config
+        .get("selected_text_style")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => completion_menu.with_selected_text_style(lookup_ansi_color_style(&value)),
+        None => completion_menu,
+    };
+
+    completion_menu = match config
+        .menu_config
+        .get("marker")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => completion_menu.with_marker(value),
+        None => completion_menu,
+    };
+
+    line_editor.with_menu(Box::new(completion_menu))
+}
+
+// Creates an input object for the history menu based on the dictionary
+// stored in the config variable
+pub(crate) fn add_history_menu(line_editor: Reedline, config: &Config) -> Reedline {
+    let mut history_menu = HistoryMenu::default();
+
+    history_menu = match config
+        .history_config
+        .get("page_size")
+        .and_then(|value| value.as_integer().ok())
+    {
+        Some(value) => history_menu.with_page_size(value as usize),
+        None => history_menu,
+    };
+
+    history_menu = match config
+        .history_config
+        .get("selector")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => {
+            let char = value.chars().next().unwrap_or('!');
+            history_menu.with_selection_char(char)
+        }
+        None => history_menu,
+    };
+
+    history_menu = match config
+        .history_config
+        .get("text_style")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => history_menu.with_text_style(lookup_ansi_color_style(&value)),
+        None => history_menu,
+    };
+
+    history_menu = match config
+        .history_config
+        .get("selected_text_style")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => history_menu.with_selected_text_style(lookup_ansi_color_style(&value)),
+        None => history_menu,
+    };
+
+    history_menu = match config
+        .history_config
+        .get("marker")
+        .and_then(|value| value.as_string().ok())
+    {
+        Some(value) => history_menu.with_marker(value),
+        None => history_menu,
+    };
+
+    line_editor.with_menu(Box::new(history_menu))
+}
+
+fn add_menu_keybindings(keybindings: &mut Keybindings) {
+    keybindings.add_binding(
+        KeyModifiers::CONTROL,
+        KeyCode::Char('x'),
+        ReedlineEvent::UntilFound(vec![
+            ReedlineEvent::Menu("history_menu".to_string()),
+            ReedlineEvent::MenuPageNext,
+        ]),
+    );
+
+    keybindings.add_binding(
+        KeyModifiers::CONTROL,
+        KeyCode::Char('z'),
+        ReedlineEvent::UntilFound(vec![
+            ReedlineEvent::MenuPagePrevious,
+            ReedlineEvent::Edit(vec![EditCommand::Undo]),
+        ]),
+    );
+
+    keybindings.add_binding(
+        KeyModifiers::NONE,
+        KeyCode::Tab,
+        ReedlineEvent::UntilFound(vec![
+            ReedlineEvent::Menu("completion_menu".to_string()),
+            ReedlineEvent::MenuNext,
+        ]),
+    );
+
+    keybindings.add_binding(
+        KeyModifiers::SHIFT,
+        KeyCode::BackTab,
+        ReedlineEvent::MenuPrevious,
+    );
+}
+
+pub enum KeybindingsMode {
+    Emacs(Keybindings),
+    Vi {
+        insert_keybindings: Keybindings,
+        normal_keybindings: Keybindings,
+    },
+}
+
+pub(crate) fn create_keybindings(config: &Config) -> Result<KeybindingsMode, ShellError> {
+    let parsed_keybindings = &config.keybindings;
+
+    let mut emacs_keybindings = default_emacs_keybindings();
+    let mut insert_keybindings = default_vi_insert_keybindings();
+    let mut normal_keybindings = default_vi_normal_keybindings();
+
+    for keybinding in parsed_keybindings {
+        add_keybinding(
+            &keybinding.mode,
+            keybinding,
+            config,
+            &mut emacs_keybindings,
+            &mut insert_keybindings,
+            &mut normal_keybindings,
+        )?
+    }
+
+    match config.edit_mode.as_str() {
+        "emacs" => {
+            add_menu_keybindings(&mut emacs_keybindings);
+
+            Ok(KeybindingsMode::Emacs(emacs_keybindings))
+        }
+        _ => {
+            add_menu_keybindings(&mut insert_keybindings);
+            add_menu_keybindings(&mut normal_keybindings);
+
+            Ok(KeybindingsMode::Vi {
+                insert_keybindings,
+                normal_keybindings,
+            })
+        }
+    }
+}
+
+fn add_keybinding(
+    mode: &Value,
+    keybinding: &ParsedKeybinding,
+    config: &Config,
+    emacs_keybindings: &mut Keybindings,
+    insert_keybindings: &mut Keybindings,
+    normal_keybindings: &mut Keybindings,
+) -> Result<(), ShellError> {
+    match &mode {
+        Value::String { val, span } => match val.as_str() {
+            "emacs" => add_parsed_keybinding(emacs_keybindings, keybinding, config),
+            "vi_insert" => add_parsed_keybinding(insert_keybindings, keybinding, config),
+            "vi_normal" => add_parsed_keybinding(normal_keybindings, keybinding, config),
+            m => Err(ShellError::UnsupportedConfigValue(
+                "emacs, vi_insert or vi_normal".to_string(),
+                m.to_string(),
+                *span,
+            )),
+        },
+        Value::List { vals, .. } => {
+            for inner_mode in vals {
+                add_keybinding(
+                    inner_mode,
+                    keybinding,
+                    config,
+                    emacs_keybindings,
+                    insert_keybindings,
+                    normal_keybindings,
+                )?
+            }
+
+            Ok(())
+        }
+        v => Err(ShellError::UnsupportedConfigValue(
+            "string or list of strings".to_string(),
+            v.into_abbreviated_string(config),
+            v.span()?,
+        )),
+    }
+}
+
+fn add_parsed_keybinding(
+    keybindings: &mut Keybindings,
+    keybinding: &ParsedKeybinding,
+    config: &Config,
+) -> Result<(), ShellError> {
+    let modifier = match keybinding
+        .modifier
+        .into_string("", config)
+        .to_lowercase()
+        .as_str()
+    {
+        "control" => KeyModifiers::CONTROL,
+        "shift" => KeyModifiers::SHIFT,
+        "alt" => KeyModifiers::ALT,
+        "none" => KeyModifiers::NONE,
+        "control | shift" => KeyModifiers::CONTROL | KeyModifiers::SHIFT,
+        "control | alt" => KeyModifiers::CONTROL | KeyModifiers::ALT,
+        "control | alt | shift" => KeyModifiers::CONTROL | KeyModifiers::ALT | KeyModifiers::SHIFT,
+        _ => {
+            return Err(ShellError::UnsupportedConfigValue(
+                "CONTROL, SHIFT, ALT or NONE".to_string(),
+                keybinding.modifier.into_abbreviated_string(config),
+                keybinding.modifier.span()?,
+            ))
+        }
+    };
+
+    let keycode = match keybinding
+        .keycode
+        .into_string("", config)
+        .to_lowercase()
+        .as_str()
+    {
+        "backspace" => KeyCode::Backspace,
+        "enter" => KeyCode::Enter,
+        c if c.starts_with("char_") => {
+            let mut char_iter = c.chars().skip(5);
+            let pos1 = char_iter.next();
+            let pos2 = char_iter.next();
+
+            let char = match (pos1, pos2) {
+                (Some(char), None) => Ok(char),
+                _ => Err(ShellError::UnsupportedConfigValue(
+                    "char_<CHAR: unicode codepoint>".to_string(),
+                    c.to_string(),
+                    keybinding.keycode.span()?,
+                )),
+            }?;
+
+            KeyCode::Char(char)
+        }
+        "down" => KeyCode::Down,
+        "up" => KeyCode::Up,
+        "left" => KeyCode::Left,
+        "right" => KeyCode::Right,
+        "home" => KeyCode::Home,
+        "end" => KeyCode::End,
+        "pageup" => KeyCode::PageUp,
+        "pagedown" => KeyCode::PageDown,
+        "tab" => KeyCode::Tab,
+        "backtab" => KeyCode::BackTab,
+        "delete" => KeyCode::Delete,
+        "insert" => KeyCode::Insert,
+        c if c.starts_with('f') => {
+            let fn_num: u8 = c[1..]
+                .parse()
+                .ok()
+                .filter(|num| matches!(num, 1..=12))
+                .ok_or(ShellError::UnsupportedConfigValue(
+                    "(f1|f2|...|f12)".to_string(),
+                    format!("unknown function key: {}", c),
+                    keybinding.keycode.span()?,
+                ))?;
+            KeyCode::F(fn_num)
+        }
+        "null" => KeyCode::Null,
+        "esc" | "escape" => KeyCode::Esc,
+        _ => {
+            return Err(ShellError::UnsupportedConfigValue(
+                "crossterm KeyCode".to_string(),
+                keybinding.keycode.into_abbreviated_string(config),
+                keybinding.keycode.span()?,
+            ))
+        }
+    };
+
+    let event = parse_event(&keybinding.event, config)?;
+
+    keybindings.add_binding(modifier, keycode, event);
+
+    Ok(())
+}
+
+enum EventType<'config> {
+    Send(&'config Value),
+    Edit(&'config Value),
+    Until(&'config Value),
+}
+
+impl<'config> EventType<'config> {
+    fn try_from_columns(
+        cols: &'config [String],
+        vals: &'config [Value],
+        span: &'config Span,
+    ) -> Result<Self, ShellError> {
+        extract_value("send", cols, vals, span)
+            .map(Self::Send)
+            .or_else(|_| extract_value("edit", cols, vals, span).map(Self::Edit))
+            .or_else(|_| extract_value("until", cols, vals, span).map(Self::Until))
+            .map_err(|_| ShellError::MissingConfigValue("send, edit or until".to_string(), *span))
+    }
+}
+
+fn parse_event(value: &Value, config: &Config) -> Result<ReedlineEvent, ShellError> {
+    match value {
+        Value::Record { cols, vals, span } => {
+            match EventType::try_from_columns(cols, vals, span)? {
+                EventType::Send(value) => event_from_record(
+                    value.into_string("", config).to_lowercase().as_str(),
+                    cols,
+                    vals,
+                    config,
+                    span,
+                ),
+                EventType::Edit(value) => {
+                    let edit = edit_from_record(
+                        value.into_string("", config).to_lowercase().as_str(),
+                        cols,
+                        vals,
+                        config,
+                        span,
+                    )?;
+                    Ok(ReedlineEvent::Edit(vec![edit]))
+                }
+                EventType::Until(value) => match value {
+                    Value::List { vals, .. } => {
+                        let events = vals
+                            .iter()
+                            .map(|value| parse_event(value, config))
+                            .collect::<Result<Vec<ReedlineEvent>, ShellError>>()?;
+
+                        Ok(ReedlineEvent::UntilFound(events))
+                    }
+                    v => Err(ShellError::UnsupportedConfigValue(
+                        "list of events".to_string(),
+                        v.into_abbreviated_string(config),
+                        v.span()?,
+                    )),
+                },
+            }
+        }
+        Value::List { vals, .. } => {
+            let events = vals
+                .iter()
+                .map(|value| parse_event(value, config))
+                .collect::<Result<Vec<ReedlineEvent>, ShellError>>()?;
+
+            Ok(ReedlineEvent::Multiple(events))
+        }
+        v => Err(ShellError::UnsupportedConfigValue(
+            "record or list of records".to_string(),
+            v.into_abbreviated_string(config),
+            v.span()?,
+        )),
+    }
+}
+
+fn event_from_record(
+    name: &str,
+    cols: &[String],
+    vals: &[Value],
+    config: &Config,
+    span: &Span,
+) -> Result<ReedlineEvent, ShellError> {
+    let event = match name {
+        "none" => ReedlineEvent::None,
+        "actionhandler" => ReedlineEvent::ActionHandler,
+        "clearscreen" => ReedlineEvent::ClearScreen,
+        "historyhintcomplete" => ReedlineEvent::HistoryHintComplete,
+        "historyhintwordcomplete" => ReedlineEvent::HistoryHintWordComplete,
+        "ctrld" => ReedlineEvent::CtrlD,
+        "ctrlc" => ReedlineEvent::CtrlC,
+        "enter" => ReedlineEvent::Enter,
+        "esc" | "escape" => ReedlineEvent::Esc,
+        "up" => ReedlineEvent::Up,
+        "down" => ReedlineEvent::Down,
+        "right" => ReedlineEvent::Right,
+        "left" => ReedlineEvent::Left,
+        "searchhistory" => ReedlineEvent::SearchHistory,
+        "nexthistory" => ReedlineEvent::NextHistory,
+        "previoushistory" => ReedlineEvent::PreviousHistory,
+        "repaint" => ReedlineEvent::Repaint,
+        "menudown" => ReedlineEvent::MenuDown,
+        "menuup" => ReedlineEvent::MenuUp,
+        "menuleft" => ReedlineEvent::MenuLeft,
+        "menuright" => ReedlineEvent::MenuRight,
+        "menunext" => ReedlineEvent::MenuNext,
+        "menuprevious" => ReedlineEvent::MenuPrevious,
+        "menupagenext" => ReedlineEvent::MenuPageNext,
+        "menupageprevious" => ReedlineEvent::MenuPagePrevious,
+        "menu" => {
+            let menu = extract_value("name", cols, vals, span)?;
+            ReedlineEvent::Menu(menu.into_string("", config))
+        }
+        "executehostcommand" => {
+            let cmd = extract_value("cmd", cols, vals, span)?;
+            ReedlineEvent::ExecuteHostCommand(cmd.into_string("", config))
+        }
+        v => {
+            return Err(ShellError::UnsupportedConfigValue(
+                "Reedline event".to_string(),
+                v.to_string(),
+                *span,
+            ))
+        }
+    };
+
+    Ok(event)
+}
+
+fn edit_from_record(
+    name: &str,
+    cols: &[String],
+    vals: &[Value],
+    config: &Config,
+    span: &Span,
+) -> Result<EditCommand, ShellError> {
+    let edit = match name {
+        "movetostart" => EditCommand::MoveToStart,
+        "movetolinestart" => EditCommand::MoveToLineStart,
+        "movetoend" => EditCommand::MoveToEnd,
+        "movetolineend" => EditCommand::MoveToLineEnd,
+        "moveleft" => EditCommand::MoveLeft,
+        "moveright" => EditCommand::MoveRight,
+        "movewordleft" => EditCommand::MoveWordLeft,
+        "movewordright" => EditCommand::MoveWordRight,
+        "insertchar" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::InsertChar(char)
+        }
+        "insertstring" => {
+            let value = extract_value("value", cols, vals, span)?;
+            EditCommand::InsertString(value.into_string("", config))
+        }
+        "backspace" => EditCommand::Backspace,
+        "delete" => EditCommand::Delete,
+        "backspaceword" => EditCommand::BackspaceWord,
+        "deleteword" => EditCommand::DeleteWord,
+        "clear" => EditCommand::Clear,
+        "cleartolineend" => EditCommand::ClearToLineEnd,
+        "cutcurrentline" => EditCommand::CutCurrentLine,
+        "cutfromstart" => EditCommand::CutFromStart,
+        "cutfromlinestart" => EditCommand::CutFromLineStart,
+        "cuttoend" => EditCommand::CutToEnd,
+        "cuttolineend" => EditCommand::CutToLineEnd,
+        "cutwordleft" => EditCommand::CutWordLeft,
+        "cutwordright" => EditCommand::CutWordRight,
+        "pastecutbufferbefore" => EditCommand::PasteCutBufferBefore,
+        "pastecutbufferafter" => EditCommand::PasteCutBufferAfter,
+        "uppercaseword" => EditCommand::UppercaseWord,
+        "lowercaseword" => EditCommand::LowercaseWord,
+        "capitalizechar" => EditCommand::CapitalizeChar,
+        "swapwords" => EditCommand::SwapWords,
+        "swapgraphemes" => EditCommand::SwapGraphemes,
+        "undo" => EditCommand::Undo,
+        "redo" => EditCommand::Redo,
+        "cutrightuntil" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::CutRightUntil(char)
+        }
+        "cutrightbefore" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::CutRightBefore(char)
+        }
+        "moverightuntil" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::MoveRightUntil(char)
+        }
+        "moverightbefore" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::MoveRightBefore(char)
+        }
+        "cutleftuntil" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::CutLeftUntil(char)
+        }
+        "cutleftbefore" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::CutLeftBefore(char)
+        }
+        "moveleftuntil" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::MoveLeftUntil(char)
+        }
+        "moveleftbefore" => {
+            let value = extract_value("value", cols, vals, span)?;
+            let char = extract_char(value, config)?;
+            EditCommand::MoveLeftBefore(char)
+        }
+        e => {
+            return Err(ShellError::UnsupportedConfigValue(
+                "reedline EditCommand".to_string(),
+                e.to_string(),
+                *span,
+            ))
+        }
+    };
+
+    Ok(edit)
+}
+
+fn extract_char(value: &Value, config: &Config) -> Result<char, ShellError> {
+    let span = value.span()?;
+    value
+        .into_string("", config)
+        .chars()
+        .next()
+        .ok_or_else(|| ShellError::MissingConfigValue("char to insert".to_string(), span))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_send_event() {
+        let cols = vec!["send".to_string()];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
+
+        let span = Span::test_data();
+        let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
+        assert!(matches!(b, EventType::Send(_)));
+
+        let event = Value::Record {
+            vals,
+            cols,
+            span: Span::test_data(),
+        };
+        let config = Config::default();
+
+        let parsed_event = parse_event(&event, &config).unwrap();
+        assert_eq!(parsed_event, ReedlineEvent::Enter);
+    }
+
+    #[test]
+    fn test_edit_event() {
+        let cols = vec!["edit".to_string()];
+        let vals = vec![Value::String {
+            val: "Clear".to_string(),
+            span: Span::test_data(),
+        }];
+
+        let span = Span::test_data();
+        let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
+        assert!(matches!(b, EventType::Edit(_)));
+
+        let event = Value::Record {
+            vals,
+            cols,
+            span: Span::test_data(),
+        };
+        let config = Config::default();
+
+        let parsed_event = parse_event(&event, &config).unwrap();
+        assert_eq!(parsed_event, ReedlineEvent::Edit(vec![EditCommand::Clear]));
+    }
+
+    #[test]
+    fn test_send_menu() {
+        let cols = vec!["send".to_string(), "name".to_string()];
+        let vals = vec![
+            Value::String {
+                val: "Menu".to_string(),
+                span: Span::test_data(),
+            },
+            Value::String {
+                val: "history_menu".to_string(),
+                span: Span::test_data(),
+            },
+        ];
+
+        let span = Span::test_data();
+        let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
+        assert!(matches!(b, EventType::Send(_)));
+
+        let event = Value::Record {
+            vals,
+            cols,
+            span: Span::test_data(),
+        };
+        let config = Config::default();
+
+        let parsed_event = parse_event(&event, &config).unwrap();
+        assert_eq!(
+            parsed_event,
+            ReedlineEvent::Menu("history_menu".to_string())
+        );
+    }
+
+    #[test]
+    fn test_until_event() {
+        // Menu event
+        let cols = vec!["send".to_string(), "name".to_string()];
+        let vals = vec![
+            Value::String {
+                val: "Menu".to_string(),
+                span: Span::test_data(),
+            },
+            Value::String {
+                val: "history_menu".to_string(),
+                span: Span::test_data(),
+            },
+        ];
+
+        let menu_event = Value::Record {
+            cols,
+            vals,
+            span: Span::test_data(),
+        };
+
+        // Enter event
+        let cols = vec!["send".to_string()];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
+
+        let enter_event = Value::Record {
+            cols,
+            vals,
+            span: Span::test_data(),
+        };
+
+        // Until event
+        let cols = vec!["until".to_string()];
+        let vals = vec![Value::List {
+            vals: vec![menu_event, enter_event],
+            span: Span::test_data(),
+        }];
+
+        let span = Span::test_data();
+        let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
+        assert!(matches!(b, EventType::Until(_)));
+
+        let event = Value::Record {
+            cols,
+            vals,
+            span: Span::test_data(),
+        };
+        let config = Config::default();
+
+        let parsed_event = parse_event(&event, &config).unwrap();
+        assert_eq!(
+            parsed_event,
+            ReedlineEvent::UntilFound(vec![
+                ReedlineEvent::Menu("history_menu".to_string()),
+                ReedlineEvent::Enter,
+            ])
+        );
+    }
+
+    #[test]
+    fn test_multiple_event() {
+        // Menu event
+        let cols = vec!["send".to_string(), "name".to_string()];
+        let vals = vec![
+            Value::String {
+                val: "Menu".to_string(),
+                span: Span::test_data(),
+            },
+            Value::String {
+                val: "history_menu".to_string(),
+                span: Span::test_data(),
+            },
+        ];
+
+        let menu_event = Value::Record {
+            cols,
+            vals,
+            span: Span::test_data(),
+        };
+
+        // Enter event
+        let cols = vec!["send".to_string()];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
+
+        let enter_event = Value::Record {
+            cols,
+            vals,
+            span: Span::test_data(),
+        };
+
+        // Multiple event
+        let event = Value::List {
+            vals: vec![menu_event, enter_event],
+            span: Span::test_data(),
+        };
+
+        let config = Config::default();
+        let parsed_event = parse_event(&event, &config).unwrap();
+        assert_eq!(
+            parsed_event,
+            ReedlineEvent::Multiple(vec![
+                ReedlineEvent::Menu("history_menu".to_string()),
+                ReedlineEvent::Enter,
+            ])
+        );
+    }
+
+    #[test]
+    fn test_error() {
+        let cols = vec!["not_exist".to_string()];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
+
+        let span = Span::test_data();
+        let b = EventType::try_from_columns(&cols, &vals, &span);
+        assert!(matches!(b, Err(ShellError::MissingConfigValue(_, _))));
+    }
+}

crates/nu-cli/src/repl.rs

@@ -0,0 +1,367 @@
+use crate::reedline_config::{add_completion_menu, add_history_menu};
+use crate::{prompt_update, reedline_config};
+use crate::{
+    reedline_config::KeybindingsMode,
+    util::{eval_source, report_error},
+};
+use crate::{NuCompleter, NuHighlighter, NuValidator, NushellPrompt};
+use log::info;
+use log::trace;
+use miette::{IntoDiagnostic, Result};
+use nu_color_config::get_color_config;
+use nu_engine::convert_env_values;
+use nu_parser::lex;
+use nu_protocol::engine::Stack;
+use nu_protocol::PipelineData;
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    Config, ShellError, Span, Value, CONFIG_VARIABLE_ID,
+};
+use reedline::{DefaultHinter, Emacs, Vi};
+use std::path::PathBuf;
+use std::{sync::atomic::Ordering, time::Instant};
+
+pub fn evaluate_repl(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    history_path: Option<PathBuf>,
+    is_perf_true: bool,
+) -> Result<()> {
+    // use crate::logger::{configure, logger};
+    use reedline::{FileBackedHistory, Reedline, Signal};
+
+    let mut entry_num = 0;
+
+    let mut nu_prompt = NushellPrompt::new();
+    // let mut stack = nu_protocol::engine::Stack::new();
+
+    // First, set up env vars as strings only
+    // gather_parent_env_vars(engine_state);
+
+    // Set up our initial config to start from
+    // stack.vars.insert(
+    //     CONFIG_VARIABLE_ID,
+    //     Value::Record {
+    //         cols: vec![],
+    //         vals: vec![],
+    //         span: Span::new(0, 0),
+    //     },
+    // );
+
+    if is_perf_true {
+        info!("read_plugin_file {}:{}:{}", file!(), line!(), column!());
+    }
+
+    // #[cfg(feature = "plugin")]
+    // config_files::read_plugin_file(engine_state, &mut stack, is_perf_true);
+    //
+    // if is_perf_true {
+    //     info!("read_config_file {}:{}:{}", file!(), line!(), column!());
+    // }
+    //
+    // config_files::read_config_file(engine_state, &mut stack, config_file, is_perf_true);
+    // let history_path = config_files::create_history_path();
+
+    // logger(|builder| {
+    //     configure(&config.log_level, builder)?;
+    //     // trace_filters(self, builder)?;
+    //     // debug_filters(self, builder)?;
+
+    //     Ok(())
+    // })?;
+
+    if is_perf_true {
+        info!(
+            "translate environment vars {}:{}:{}",
+            file!(),
+            line!(),
+            column!()
+        );
+    }
+
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+    }
+
+    // Make a note of the exceptions we see for externals that look like math expressions
+    let exceptions = crate::util::external_exceptions(engine_state, stack);
+    engine_state.external_exceptions = exceptions;
+
+    // seed env vars
+    stack.add_env_var(
+        "CMD_DURATION_MS".into(),
+        Value::String {
+            val: "0823".to_string(),
+            span: Span { start: 0, end: 0 },
+        },
+    );
+
+    stack.add_env_var(
+        "LAST_EXIT_CODE".into(),
+        Value::Int {
+            val: 0,
+            span: Span { start: 0, end: 0 },
+        },
+    );
+
+    loop {
+        if is_perf_true {
+            info!(
+                "load config each loop {}:{}:{}",
+                file!(),
+                line!(),
+                column!()
+            );
+        }
+
+        let config = match stack.get_config() {
+            Ok(config) => config,
+            Err(e) => {
+                let working_set = StateWorkingSet::new(engine_state);
+
+                report_error(&working_set, &e);
+                Config::default()
+            }
+        };
+
+        //Reset the ctrl-c handler
+        if let Some(ctrlc) = &mut engine_state.ctrlc {
+            ctrlc.store(false, Ordering::SeqCst);
+        }
+
+        if is_perf_true {
+            info!("setup line editor {}:{}:{}", file!(), line!(), column!());
+        }
+
+        let mut line_editor = Reedline::create()
+            .into_diagnostic()?
+            .with_highlighter(Box::new(NuHighlighter {
+                engine_state: engine_state.clone(),
+                config: config.clone(),
+            }))
+            .with_animation(config.animate_prompt)
+            .with_validator(Box::new(NuValidator {
+                engine_state: engine_state.clone(),
+            }))
+            .with_completer(Box::new(NuCompleter::new(
+                engine_state.clone(),
+                stack.vars.get(&CONFIG_VARIABLE_ID).cloned(),
+            )))
+            .with_quick_completions(config.quick_completions)
+            .with_partial_completions(config.partial_completions)
+            .with_ansi_colors(config.use_ansi_coloring);
+
+        if is_perf_true {
+            info!("setup reedline {}:{}:{}", file!(), line!(), column!());
+        }
+
+        line_editor = add_completion_menu(line_editor, &config);
+        line_editor = add_history_menu(line_editor, &config);
+
+        if is_perf_true {
+            info!("setup colors {}:{}:{}", file!(), line!(), column!());
+        }
+        //FIXME: if config.use_ansi_coloring is false then we should
+        // turn off the hinter but I don't see any way to do that yet.
+
+        let color_hm = get_color_config(&config);
+
+        if is_perf_true {
+            info!(
+                "setup history and hinter {}:{}:{}",
+                file!(),
+                line!(),
+                column!()
+            );
+        }
+
+        line_editor = if let Some(history_path) = history_path.clone() {
+            let history = std::fs::read_to_string(&history_path);
+            if history.is_ok() {
+                line_editor
+                    .with_hinter(Box::new(
+                        DefaultHinter::default().with_style(color_hm["hints"]),
+                    ))
+                    .with_history(Box::new(
+                        FileBackedHistory::with_file(
+                            config.max_history_size as usize,
+                            history_path.clone(),
+                        )
+                        .into_diagnostic()?,
+                    ))
+                    .into_diagnostic()?
+            } else {
+                line_editor
+            }
+        } else {
+            line_editor
+        };
+
+        if is_perf_true {
+            info!("setup keybindings {}:{}:{}", file!(), line!(), column!());
+        }
+
+        // Changing the line editor based on the found keybindings
+        line_editor = match reedline_config::create_keybindings(&config) {
+            Ok(keybindings) => match keybindings {
+                KeybindingsMode::Emacs(keybindings) => {
+                    let edit_mode = Box::new(Emacs::new(keybindings));
+                    line_editor.with_edit_mode(edit_mode)
+                }
+                KeybindingsMode::Vi {
+                    insert_keybindings,
+                    normal_keybindings,
+                } => {
+                    let edit_mode = Box::new(Vi::new(insert_keybindings, normal_keybindings));
+                    line_editor.with_edit_mode(edit_mode)
+                }
+            },
+            Err(e) => {
+                let working_set = StateWorkingSet::new(engine_state);
+                report_error(&working_set, &e);
+                line_editor
+            }
+        };
+
+        if is_perf_true {
+            info!("prompt_update {}:{}:{}", file!(), line!(), column!());
+        }
+
+        let prompt = prompt_update::update_prompt(
+            &config,
+            engine_state,
+            stack,
+            &mut nu_prompt,
+            is_perf_true,
+        );
+
+        entry_num += 1;
+
+        if is_perf_true {
+            info!(
+                "finished setup, starting repl {}:{}:{}",
+                file!(),
+                line!(),
+                column!()
+            );
+        }
+
+        let input = line_editor.read_line(prompt);
+        match input {
+            Ok(Signal::Success(s)) => {
+                let start_time = Instant::now();
+                let tokens = lex(s.as_bytes(), 0, &[], &[], false);
+                // Check if this is a single call to a directory, if so auto-cd
+                let cwd = nu_engine::env::current_dir_str(engine_state, stack)?;
+                let path = nu_path::expand_path_with(&s, &cwd);
+
+                let orig = s.clone();
+
+                if (orig.starts_with('.')
+                    || orig.starts_with('~')
+                    || orig.starts_with('/')
+                    || orig.starts_with('\\'))
+                    && path.is_dir()
+                    && tokens.0.len() == 1
+                {
+                    // We have an auto-cd
+                    let (path, span) = {
+                        if !path.exists() {
+                            let working_set = StateWorkingSet::new(engine_state);
+
+                            report_error(
+                                &working_set,
+                                &ShellError::DirectoryNotFound(tokens.0[0].span),
+                            );
+                        }
+
+                        let path = nu_path::canonicalize_with(path, &cwd)
+                            .expect("internal error: cannot canonicalize known path");
+                        (path.to_string_lossy().to_string(), tokens.0[0].span)
+                    };
+
+                    //FIXME: this only changes the current scope, but instead this environment variable
+                    //should probably be a block that loads the information from the state in the overlay
+                    stack.add_env_var(
+                        "PWD".into(),
+                        Value::String {
+                            val: path.clone(),
+                            span: Span { start: 0, end: 0 },
+                        },
+                    );
+                    let cwd = Value::String { val: cwd, span };
+
+                    let shells = stack.get_env_var(engine_state, "NUSHELL_SHELLS");
+                    let mut shells = if let Some(v) = shells {
+                        v.as_list()
+                            .map(|x| x.to_vec())
+                            .unwrap_or_else(|_| vec![cwd])
+                    } else {
+                        vec![cwd]
+                    };
+
+                    let current_shell = stack.get_env_var(engine_state, "NUSHELL_CURRENT_SHELL");
+                    let current_shell = if let Some(v) = current_shell {
+                        v.as_integer().unwrap_or_default() as usize
+                    } else {
+                        0
+                    };
+
+                    shells[current_shell] = Value::String { val: path, span };
+
+                    stack.add_env_var("NUSHELL_SHELLS".into(), Value::List { vals: shells, span });
+                } else {
+                    trace!("eval source: {}", s);
+
+                    eval_source(
+                        engine_state,
+                        stack,
+                        s.as_bytes(),
+                        &format!("entry #{}", entry_num),
+                        PipelineData::new(Span::new(0, 0)),
+                    );
+
+                    stack.add_env_var(
+                        "CMD_DURATION_MS".into(),
+                        Value::String {
+                            val: format!("{}", start_time.elapsed().as_millis()),
+                            span: Span { start: 0, end: 0 },
+                        },
+                    );
+                }
+                // FIXME: permanent state changes like this hopefully in time can be removed
+                // and be replaced by just passing the cwd in where needed
+                if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
+                    let path = cwd.as_string()?;
+                    let _ = std::env::set_current_dir(path);
+                    engine_state.env_vars.insert("PWD".into(), cwd);
+                }
+
+                // Make a note of the exceptions we see for externals that look like math expressions
+                let exceptions = crate::util::external_exceptions(engine_state, stack);
+                engine_state.external_exceptions = exceptions;
+            }
+            Ok(Signal::CtrlC) => {
+                // `Reedline` clears the line content. New prompt is shown
+            }
+            Ok(Signal::CtrlD) => {
+                // When exiting clear to a new line
+                println!();
+                break;
+            }
+            Ok(Signal::CtrlL) => {
+                line_editor.clear_screen().into_diagnostic()?;
+            }
+            Err(err) => {
+                let message = err.to_string();
+                if !message.contains("duration") {
+                    println!("Error: {:?}", err);
+                }
+            }
+        }
+    }
+
+    Ok(())
+}

crates/nu-cli/src/util.rs

@@ -1,5 +1,11 @@
+use log::trace;
+use nu_engine::eval_block;
+use nu_parser::{lex, parse, trim_quotes, Token, TokenContents};
 use std::io::Write;
+use std::path::PathBuf;
 
+use crate::CliError;
+use nu_protocol::engine::StateWorkingSet;
 use nu_protocol::{
     ast::Call,
     engine::{EngineState, Stack},
@@ -84,3 +90,419 @@ pub fn print_pipeline_data(
 
     Ok(())
 }
+
+// This will collect environment variables from std::env and adds them to a stack.
+//
+// In order to ensure the values have spans, it first creates a dummy file, writes the collected
+// env vars into it (in a "NAME"="value" format, quite similar to the output of the Unix 'env'
+// tool), then uses the file to get the spans. The file stays in memory, no filesystem IO is done.
+pub fn gather_parent_env_vars(engine_state: &mut EngineState) {
+    // Some helper functions
+    fn get_surround_char(s: &str) -> Option<char> {
+        if s.contains('"') {
+            if s.contains('\'') {
+                None
+            } else {
+                Some('\'')
+            }
+        } else {
+            Some('\'')
+        }
+    }
+
+    fn report_capture_error(engine_state: &EngineState, env_str: &str, msg: &str) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(
+            &working_set,
+            &ShellError::LabeledError(
+                format!("Environment variable was not captured: {}", env_str),
+                msg.into(),
+            ),
+        );
+    }
+
+    fn put_env_to_fake_file(
+        name: &str,
+        val: &str,
+        fake_env_file: &mut String,
+        engine_state: &EngineState,
+    ) {
+        let (c_name, c_val) =
+            if let (Some(cn), Some(cv)) = (get_surround_char(name), get_surround_char(val)) {
+                (cn, cv)
+            } else {
+                // environment variable with its name or value containing both ' and " is ignored
+                report_capture_error(
+                    engine_state,
+                    &format!("{}={}", name, val),
+                    "Name or value should not contain both ' and \" at the same time.",
+                );
+                return;
+            };
+
+        fake_env_file.push(c_name);
+        fake_env_file.push_str(name);
+        fake_env_file.push(c_name);
+        fake_env_file.push('=');
+        fake_env_file.push(c_val);
+        fake_env_file.push_str(val);
+        fake_env_file.push(c_val);
+        fake_env_file.push('\n');
+    }
+
+    let mut fake_env_file = String::new();
+
+    // Make sure we always have PWD
+    if std::env::var("PWD").is_err() {
+        match std::env::current_dir() {
+            Ok(cwd) => {
+                put_env_to_fake_file(
+                    "PWD",
+                    &cwd.to_string_lossy(),
+                    &mut fake_env_file,
+                    engine_state,
+                );
+            }
+            Err(e) => {
+                // Could not capture current working directory
+                let working_set = StateWorkingSet::new(engine_state);
+                report_error(
+                    &working_set,
+                    &ShellError::LabeledError(
+                        "Current directory not found".to_string(),
+                        format!("Retrieving current directory failed: {:?}", e),
+                    ),
+                );
+            }
+        }
+    }
+
+    // Write all the env vars into a fake file
+    for (name, val) in std::env::vars() {
+        put_env_to_fake_file(&name, &val, &mut fake_env_file, engine_state);
+    }
+
+    // Lex the fake file, assign spans to all environment variables and add them
+    // to stack
+    let span_offset = engine_state.next_span_start();
+
+    engine_state.add_file(
+        "Host Environment Variables".to_string(),
+        fake_env_file.as_bytes().to_vec(),
+    );
+
+    let (tokens, _) = lex(fake_env_file.as_bytes(), span_offset, &[], &[], true);
+
+    for token in tokens {
+        if let Token {
+            contents: TokenContents::Item,
+            span: full_span,
+        } = token
+        {
+            let contents = engine_state.get_span_contents(&full_span);
+            let (parts, _) = lex(contents, full_span.start, &[], &[b'='], true);
+
+            let name = if let Some(Token {
+                contents: TokenContents::Item,
+                span,
+            }) = parts.get(0)
+            {
+                let bytes = engine_state.get_span_contents(span);
+
+                if bytes.len() < 2 {
+                    report_capture_error(
+                        engine_state,
+                        &String::from_utf8_lossy(contents),
+                        "Got empty name.",
+                    );
+
+                    continue;
+                }
+
+                let bytes = trim_quotes(bytes);
+                String::from_utf8_lossy(bytes).to_string()
+            } else {
+                report_capture_error(
+                    engine_state,
+                    &String::from_utf8_lossy(contents),
+                    "Got empty name.",
+                );
+
+                continue;
+            };
+
+            let value = if let Some(Token {
+                contents: TokenContents::Item,
+                span,
+            }) = parts.get(2)
+            {
+                let bytes = engine_state.get_span_contents(span);
+
+                if bytes.len() < 2 {
+                    report_capture_error(
+                        engine_state,
+                        &String::from_utf8_lossy(contents),
+                        "Got empty value.",
+                    );
+
+                    continue;
+                }
+
+                let bytes = trim_quotes(bytes);
+
+                Value::String {
+                    val: String::from_utf8_lossy(bytes).to_string(),
+                    span: *span,
+                }
+            } else {
+                report_capture_error(
+                    engine_state,
+                    &String::from_utf8_lossy(contents),
+                    "Got empty value.",
+                );
+
+                continue;
+            };
+
+            // stack.add_env_var(name, value);
+            engine_state.env_vars.insert(name, value);
+        }
+    }
+}
+
+pub fn eval_source(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    source: &[u8],
+    fname: &str,
+    input: PipelineData,
+) -> bool {
+    trace!("eval_source");
+
+    let (block, delta) = {
+        let mut working_set = StateWorkingSet::new(engine_state);
+        let (output, err) = parse(
+            &mut working_set,
+            Some(fname), // format!("entry #{}", entry_num)
+            source,
+            false,
+        );
+        if let Some(err) = err {
+            report_error(&working_set, &err);
+            return false;
+        }
+
+        (output, working_set.render())
+    };
+
+    let cwd = match nu_engine::env::current_dir_str(engine_state, stack) {
+        Ok(p) => PathBuf::from(p),
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
+            get_init_cwd()
+        }
+    };
+
+    if let Err(err) = engine_state.merge_delta(delta, Some(stack), &cwd) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &err);
+    }
+
+    match eval_block(engine_state, stack, &block, input, false, false) {
+        Ok(mut pipeline_data) => {
+            if let PipelineData::ExternalStream { exit_code, .. } = &mut pipeline_data {
+                if let Some(exit_code) = exit_code.take().and_then(|it| it.last()) {
+                    stack.add_env_var("LAST_EXIT_CODE".to_string(), exit_code);
+                } else {
+                    stack.add_env_var(
+                        "LAST_EXIT_CODE".to_string(),
+                        Value::Int {
+                            val: 0,
+                            span: Span { start: 0, end: 0 },
+                        },
+                    );
+                }
+            } else {
+                stack.add_env_var(
+                    "LAST_EXIT_CODE".to_string(),
+                    Value::Int {
+                        val: 0,
+                        span: Span { start: 0, end: 0 },
+                    },
+                );
+            }
+
+            if let Err(err) = print_pipeline_data(pipeline_data, engine_state, stack) {
+                let working_set = StateWorkingSet::new(engine_state);
+
+                report_error(&working_set, &err);
+
+                return false;
+            }
+
+            // reset vt processing, aka ansi because illbehaved externals can break it
+            #[cfg(windows)]
+            {
+                let _ = enable_vt_processing();
+            }
+        }
+        Err(err) => {
+            stack.add_env_var(
+                "LAST_EXIT_CODE".to_string(),
+                Value::Int {
+                    val: 1,
+                    span: Span { start: 0, end: 0 },
+                },
+            );
+
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &err);
+
+            return false;
+        }
+    }
+
+    true
+}
+
+fn seems_like_number(bytes: &[u8]) -> bool {
+    if bytes.is_empty() {
+        false
+    } else {
+        let b = bytes[0];
+
+        b == b'0'
+            || b == b'1'
+            || b == b'2'
+            || b == b'3'
+            || b == b'4'
+            || b == b'5'
+            || b == b'6'
+            || b == b'7'
+            || b == b'8'
+            || b == b'9'
+            || b == b'('
+            || b == b'{'
+            || b == b'['
+            || b == b'$'
+            || b == b'"'
+            || b == b'\''
+            || b == b'-'
+    }
+}
+
+/// Finds externals that have names that look like math expressions
+pub fn external_exceptions(engine_state: &EngineState, stack: &Stack) -> Vec<Vec<u8>> {
+    let mut executables = vec![];
+
+    if let Some(path) = stack.get_env_var(engine_state, "PATH") {
+        match path {
+            Value::List { vals, .. } => {
+                for val in vals {
+                    let path = val.as_string();
+
+                    if let Ok(path) = path {
+                        if let Ok(mut contents) = std::fs::read_dir(path) {
+                            while let Some(Ok(item)) = contents.next() {
+                                if is_executable::is_executable(&item.path()) {
+                                    if let Ok(name) = item.file_name().into_string() {
+                                        if seems_like_number(name.as_bytes()) {
+                                            let name = name.as_bytes().to_vec();
+                                            executables.push(name);
+                                        }
+                                    }
+
+                                    if let Some(name) = item.path().file_stem() {
+                                        let name = name.to_string_lossy();
+                                        if seems_like_number(name.as_bytes()) {
+                                            let name = name.as_bytes().to_vec();
+                                            executables.push(name);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            Value::String { val, .. } => {
+                for path in std::env::split_paths(&val) {
+                    let path = path.to_string_lossy().to_string();
+
+                    if let Ok(mut contents) = std::fs::read_dir(path) {
+                        while let Some(Ok(item)) = contents.next() {
+                            if is_executable::is_executable(&item.path()) {
+                                if let Ok(name) = item.file_name().into_string() {
+                                    if seems_like_number(name.as_bytes()) {
+                                        let name = name.as_bytes().to_vec();
+                                        executables.push(name);
+                                    }
+                                }
+                                if let Some(name) = item.path().file_stem() {
+                                    let name = name.to_string_lossy();
+                                    if seems_like_number(name.as_bytes()) {
+                                        let name = name.as_bytes().to_vec();
+                                        executables.push(name);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    executables
+}
+
+#[cfg(windows)]
+pub fn enable_vt_processing() -> Result<(), ShellError> {
+    use crossterm_winapi::{ConsoleMode, Handle};
+
+    pub const ENABLE_PROCESSED_OUTPUT: u32 = 0x0001;
+    pub const ENABLE_VIRTUAL_TERMINAL_PROCESSING: u32 = 0x0004;
+    // let mask = ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+
+    let console_mode = ConsoleMode::from(Handle::current_out_handle()?);
+    let old_mode = console_mode.mode()?;
+
+    // researching odd ansi behavior in windows terminal repo revealed that
+    // enable_processed_output and enable_virtual_terminal_processing should be used
+    // also, instead of checking old_mode & mask, just set the mode already
+
+    // if old_mode & mask == 0 {
+    console_mode
+        .set_mode(old_mode | ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING)?;
+    // }
+
+    Ok(())
+}
+
+pub fn report_error(
+    working_set: &StateWorkingSet,
+    error: &(dyn miette::Diagnostic + Send + Sync + 'static),
+) {
+    eprintln!("Error: {:?}", CliError(error, working_set));
+    // reset vt processing, aka ansi because illbehaved externals can break it
+    #[cfg(windows)]
+    {
+        let _ = enable_vt_processing();
+    }
+}
+
+pub fn get_init_cwd() -> PathBuf {
+    match std::env::current_dir() {
+        Ok(cwd) => cwd,
+        Err(_) => match std::env::var("PWD") {
+            Ok(cwd) => PathBuf::from(cwd),
+            Err(_) => match nu_path::home_dir() {
+                Some(cwd) => cwd,
+                None => PathBuf::new(),
+            },
+        },
+    }
+}