separate commandline into subcommands (#11877)

<!--
if this PR closes one or more issues, you can automatically link the PR
with
them by using one of the [*linking
keywords*](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword),
e.g.
- this PR should close #xxxx
- fixes #xxxx

you can also mention related issues, PRs or discussions!
-->

# Description
<!--
Thank you for improving Nushell. Please, check our [contributing
guide](../CONTRIBUTING.md) and talk to the core team before making major
changes.

Description of your pull request goes here. **Provide examples and/or
screenshots** if your changes affect the user experience.
-->
Related issue and PR, #11825 #11864 
This improves the signature of `commandline`.

## Before

`commandline` returns different types depending on the flags and an
aurgument.

| command | input | output | description |

|-----------------------------|---------|---------|----------------------------------------|
| `commandline` | nothing | string | get current cursor line |
| `commandline arg` | nothing | nothing | replace the cursor line with
`arg` |
| `commandline --append arg` | nothing | nothing | append `arg` to the
end of cursor line |
| `commandline --insert arg` | nothing | nothing | insert `arg` to the
position of cursor |
| `commandline --replace arg` | nothing | nothing | replace the cursor
line with `arg` |
| `commandline --cursor` | nothing | int | get current cursor position |
| `commandline --cursor pos` | nothing | nothing | set cursor position
to pos |
| `commandline --cursor-end` | nothing | nothing | set cursor position
to end |

`help commandline` shows that `commandline` accepts string as pipeline
input, but `commandline` ignores pipeline input.

```
Input/output types:
  ╭───┬─────────┬─────────╮
  │ # │  input  │ output  │
  ├───┼─────────┼─────────┤
  │ 0 │ nothing │ nothing │
  │ 1 │ string  │ string  │
  ╰───┴─────────┴─────────╯
```

https://github.com/nushell/nushell/blob/671bd08bcda06ab340a05f960a03dd691e59c51a/crates/nu-cli/src/commands/commandline.rs#L70

This is misleading.

Due to the change #11864 , typecheck does not work well.
nushell/nushell#11864 (comment)

## After

Separate `commandline` into subcommands so that each subcommands returns
the same type for the same input type.

| command | input | output | description |

|----------------------------------|---------|---------|----------------------------------------|
| `commandline` | nothing | string | get current cursor line |
| `commandline edit arg` | nothing | nothing | replace the cursor line
with `arg` |
| `commandline edit --append arg` | nothing | nothing | append `arg` to
the end of cursor line |
| `commandline edit --insert arg` | nothing | nothing | insert `arg` to
the position of cursor |
| `commandline edit --replace arg` | nothing | nothing | replace the
cursor line with `arg` |
| `commandline get-cursor` | nothing | int | get current cursor position
|
| `commandline set-cursor pos` | nothing | nothing | set cursor position
to pos |
| `commandline set-cursor --end` | nothing | nothing | set cursor
position to end |

# User-Facing Changes
<!-- List of all changes that impact the user experience here. This
helps us keep track of breaking changes. -->

# Tests + Formatting
<!--
Don't forget to add tests that cover your changes.

Make sure you've run and fixed any issues with these commands:

- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used` to
check that you're using the standard code style
- `cargo test --workspace` to check that all tests pass (on Windows make
sure to [enable developer
mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging))
- `cargo run -- -c "use std testing; testing run-tests --path
crates/nu-std"` to run the tests for the standard library

> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```
-->

# After Submitting
<!-- If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.
-->

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

@@ -19,7 +19,6 @@ impl Command for Commandline {
             .input_output_types(vec![
                 (Type::Nothing, Type::Nothing),
                 (Type::String, Type::String),
-                (Type::String, Type::Int),
             ])
             .switch(
                 "cursor",
@@ -75,6 +74,17 @@ impl Command for Commandline {
             let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
 
             if call.has_flag(engine_state, stack, "cursor")? {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--cursor (-c)` is deprecated".into(),
+                        msg: "Setting the current cursor position by `--cursor (-c)` is deprecated"
+                            .into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline set-cursor`".into()),
+                        inner: vec![],
+                    },
+                );
                 match cmd.parse::<i64>() {
                     Ok(n) => {
                         repl.cursor_pos = if n <= 0 {
@@ -97,38 +107,80 @@ impl Command for Commandline {
                     }
                 }
             } else if call.has_flag(engine_state, stack, "append")? {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--append (-a)` is deprecated".into(),
+                        msg: "Appending the string to the end of the buffer by `--append (-a)` is deprecated".into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline edit --append (-a)`".into()),
+                        inner: vec![],
+                    },
+                );
                 repl.buffer.push_str(&cmd);
             } else if call.has_flag(engine_state, stack, "insert")? {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--insert (-i)` is deprecated".into(),
+                        msg: "Inserts the string into the buffer at the cursor position by `--insert (-i)` is deprecated".into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline edit --insert (-i)`".into()),
+                        inner: vec![],
+                    },
+                );
                 let cursor_pos = repl.cursor_pos;
                 repl.buffer.insert_str(cursor_pos, &cmd);
                 repl.cursor_pos += cmd.len();
             } else {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--replace (-r)` is deprecated".into(),
+                        msg: "Replaceing the current contents of the buffer by `--replace (-p)` or positional argument is deprecated".into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline edit --replace (-r)`".into()),
+                        inner: vec![],
+                    },
+                );
                 repl.buffer = cmd;
                 repl.cursor_pos = repl.buffer.len();
             }
             Ok(Value::nothing(call.head).into_pipeline_data())
         } else {
             let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
             if call.has_flag(engine_state, stack, "cursor-end")? {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--cursor-end (-e)` is deprecated".into(),
+                        msg: "Setting the current cursor position to the end of the buffer by `--cursor-end (-e)` is deprecated".into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline set-cursor --end (-e)`".into()),
+                        inner: vec![],
+                    },
+                );
                 repl.cursor_pos = repl.buffer.len();
                 Ok(Value::nothing(call.head).into_pipeline_data())
             } else if call.has_flag(engine_state, stack, "cursor")? {
+                nu_protocol::report_error_new(
+                    engine_state,
+                    &ShellError::GenericError {
+                        error: "`--cursor (-c)` is deprecated".into(),
+                        msg: "Getting the current cursor position by `--cursor (-c)` is deprecated"
+                            .into(),
+                        span: Some(call.arguments_span()),
+                        help: Some("Use `commandline get-cursor`".into()),
+                        inner: vec![],
+                    },
+                );
                 let char_pos = repl
                     .buffer
                     .grapheme_indices(true)
                     .chain(std::iter::once((repl.buffer.len(), "")))
                     .position(|(i, _c)| i == repl.cursor_pos)
                     .expect("Cursor position isn't on a grapheme boundary");
-                match i64::try_from(char_pos) {
-                    Ok(pos) => Ok(Value::int(pos, call.head).into_pipeline_data()),
-                    Err(e) => Err(ShellError::GenericError {
-                        error: "Failed to convert cursor position to int".to_string(),
-                        msg: e.to_string(),
-                        span: None,
-                        help: None,
-                        inner: vec![],
-                    }),
-                }
+                Ok(Value::string(char_pos.to_string(), call.head).into_pipeline_data())
             } else {
                 Ok(Value::string(repl.buffer.to_string(), call.head).into_pipeline_data())
             }

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

@@ -0,0 +1,71 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "commandline edit"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .switch(
+                "append",
+                "appends the string to the end of the buffer",
+                Some('a'),
+            )
+            .switch(
+                "insert",
+                "inserts the string into the buffer at the cursor position",
+                Some('i'),
+            )
+            .switch(
+                "replace",
+                "replaces the current contents of the buffer (default)",
+                Some('r'),
+            )
+            .required(
+                "str",
+                SyntaxShape::String,
+                "the string to perform the operation with",
+            )
+            .category(Category::Core)
+    }
+
+    fn usage(&self) -> &str {
+        "Modify the current command line input buffer."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["repl", "interactive"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let str: String = call.req(engine_state, stack, 0)?;
+        let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
+        if call.has_flag(engine_state, stack, "append")? {
+            repl.buffer.push_str(&str);
+        } else if call.has_flag(engine_state, stack, "insert")? {
+            let cursor_pos = repl.cursor_pos;
+            repl.buffer.insert_str(cursor_pos, &str);
+            repl.cursor_pos += str.len();
+        } else {
+            repl.buffer = str;
+            repl.cursor_pos = repl.buffer.len();
+        }
+        Ok(Value::nothing(call.head).into_pipeline_data())
+    }
+}

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

@@ -0,0 +1,56 @@
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, ShellError, Signature, Type, Value,
+};
+use unicode_segmentation::UnicodeSegmentation;
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "commandline get-cursor"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .input_output_types(vec![(Type::Nothing, Type::Int)])
+            .allow_variants_without_examples(true)
+            .category(Category::Core)
+    }
+
+    fn usage(&self) -> &str {
+        "Get the current cursor position."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["repl", "interactive"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let repl = engine_state.repl_state.lock().expect("repl state mutex");
+        let char_pos = repl
+            .buffer
+            .grapheme_indices(true)
+            .chain(std::iter::once((repl.buffer.len(), "")))
+            .position(|(i, _c)| i == repl.cursor_pos)
+            .expect("Cursor position isn't on a grapheme boundary");
+        match i64::try_from(char_pos) {
+            Ok(pos) => Ok(Value::int(pos, call.head).into_pipeline_data()),
+            Err(e) => Err(ShellError::GenericError {
+                error: "Failed to convert cursor position to int".to_string(),
+                msg: e.to_string(),
+                span: None,
+                help: None,
+                inner: vec![],
+            }),
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+mod commandline_;
+mod edit;
+mod get_cursor;
+mod set_cursor;
+
+pub use commandline_::Commandline;
+pub use edit::SubCommand as CommandlineEdit;
+pub use get_cursor::SubCommand as CommandlineGetCursor;
+pub use set_cursor::SubCommand as CommandlineSetCursor;

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

@@ -0,0 +1,69 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
+};
+use unicode_segmentation::UnicodeSegmentation;
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "commandline set-cursor"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .switch(
+                "end",
+                "set the current cursor position to the end of the buffer",
+                Some('e'),
+            )
+            .optional("pos", SyntaxShape::Int, "Cursor position to be set")
+            .category(Category::Core)
+    }
+
+    fn usage(&self) -> &str {
+        "Set the current cursor position."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["repl", "interactive"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
+        if let Some(pos) = call.opt::<i64>(engine_state, stack, 0)? {
+            repl.cursor_pos = if pos <= 0 {
+                0usize
+            } else {
+                repl.buffer
+                    .grapheme_indices(true)
+                    .map(|(i, _c)| i)
+                    .nth(pos as usize)
+                    .unwrap_or(repl.buffer.len())
+            };
+            Ok(Value::nothing(call.head).into_pipeline_data())
+        } else if call.has_flag(engine_state, stack, "end")? {
+            repl.cursor_pos = repl.buffer.len();
+            Ok(Value::nothing(call.head).into_pipeline_data())
+        } else {
+            Err(ShellError::GenericError {
+                error: "Required a positional argument or a flag".to_string(),
+                msg: "".to_string(),
+                span: None,
+                help: None,
+                inner: vec![],
+            })
+        }
+    }
+}

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

@@ -14,6 +14,9 @@ pub fn add_cli_context(mut engine_state: EngineState) -> EngineState {
 
         bind_command! {
             Commandline,
+            CommandlineEdit,
+            CommandlineGetCursor,
+            CommandlineSetCursor,
             History,
             HistorySession,
             Keybindings,

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

@@ -6,7 +6,7 @@ mod keybindings_default;
 mod keybindings_list;
 mod keybindings_listen;
 
-pub use commandline::Commandline;
+pub use commandline::{Commandline, CommandlineEdit, CommandlineGetCursor, CommandlineSetCursor};
 pub use history::{History, HistorySession};
 pub use keybindings::Keybindings;
 pub use keybindings_default::KeybindingsDefault;