valkey-cli: Add word-jump navigation (Alt/Option/Ctrl + ←/→) (valkey-io#2583)

Interactive use of valkey-cli often involves working with long keys
(e.g. MY:INCREDIBLY:LONG:keythattakesalongtimetotype). In shells like
bash, zsh, or psql, users can quickly move the cursor word by word with
**Alt/Option+Left/Right**, **Ctrl+Left/Right** or **Alt/Option+b/f**.
This makes editing long commands much more efficient.

Until now, valkey-cli (via linenoise) only supported single-character
cursor moves, which is painful for frequent key editing.

This patch adds such support, with simple code changes in linenoise. It
now supports both the Meta (Alt/Option) style and CSI (control sequence
introducer) style:

| | Meta style | CSI style (Ctrl) | CSI style (Alt) |
| --------------- | ---------- | ---------------- | --------- |
| move word left  | ESC b      | ESC [1;5D        | ESC [1;3D |
| move word right | ESC f      | ESC [1;5C        | ESC [1;3C |

Notice that I handle these two styles differently since people have
different preference on the definition of "what is a word".
Specifically, I define:
- "sub-word": just letters and digits. For example "my:namespace:key"
has 3 sub-words. This is handled by Meta style.
- "big-word": as any character that is not space. For example
"my:namespace:key" is just one single big-word. This is handled by CSI
style.


## How I verified

I'm using MacOS default terminal (`$TERM = xterm-256color`). I
customized the terminal keyboard setting to map option + left to `\033b`
, and ctrl + left to `\033[1;5D` so that I can produce both the Meta
style and CSI style. This code change should also work for
Linux/BSD/other terminal users.

Now the valkey-cli works like the following. `|` shows where the cursor
is currently at.

Press Alt + left (escape sequence `ESC b` ):

```
set cache:item itemid
                   |

set cache:item itemid
               |

set cache:item itemid
          |

set cache:item itemid
    |

set cache:item itemid
|
```

Press Ctrl + left (escape sequence `ESC [1;5D` ):

```
set cache:item itemid
                    |

set cache:item itemid
               |

set cache:item itemid
    |

set cache:item itemid
|
```

Press Alt + right (escape sequence `ESC f` ):

```
set cache:item itemid
|

set cache:item itemid
    |

set cache:item itemid
          |	

set cache:item itemid
               |

set cache:item itemid
                     |
```

Press Ctrl + right  (escape sequence `ESC [1;5C` ):

```
set cache:item itemid
|

set cache:item itemid
   |
    
set cache:item itemid
              |    

set cache:item itemid
                     |
```

---------

Signed-off-by: Zhijun <dszhijun@gmail.com>

Author: zhijun42

deps/linenoise/example.c

@@ -60,7 +60,7 @@ int main(int argc, char **argv) {
         /* Do something with the string. */
         if (line[0] != '\0' && line[0] != '/') {
             printf("echo: '%s'\n", line);
-            linenoiseHistoryAdd(line); /* Add to the history. */
+            linenoiseHistoryAdd(line, 0); /* Add to the history. */
             linenoiseHistorySave("history.txt"); /* Save the history on disk. */
         } else if (!strncmp(line,"/historylen",11)) {
             /* The "/historylen" command will change the history len. */

deps/linenoise/linenoise.c

@@ -708,6 +708,49 @@ void linenoiseEditMoveRight(struct linenoiseState *l) {
     }
 }
 
+/* People have different preferences on what is considered a word
+ * when editing commandline. For example, in command
+ * `set business:department:product value`,
+ * some might treat the entire long key as a word, while others
+ * treat it as 3 subwords and prefer granular word jumping navigation
+ * to make fixing a typo (e.g. "business:deaprtment:product") easier.
+ * In order to accommodate this, we treat escape sequences
+ * ESC b/f (usually Alt + ←/→ on MacOS, but you might get ESC[1;3D/C) and
+ * ESC[1;5D/C (usually Ctrl + ←/→) differently.
+ *
+ * Notice that the exact behavior of key mapping depends on your
+ * terminal/keyboard setup. To see how your environment maps keys
+ * to escape sequences, you can run command `cat -v` and then press
+ * arbitrary keys to see how they work.
+ */
+static int isSubWordDelimiter(const char c) {
+    return !isalnum(c);
+}
+static int isBigWordDelimiter(const char c) {
+    return isspace(c);
+}
+
+typedef int (*isDelimiterFunc)(char c);
+
+static void linenoiseEditMoveWordLeft(struct linenoiseState *l, const isDelimiterFunc isDelimiter) {
+    if (l->pos == 0) return;
+    /* Move cursor to the left over any delimiters */
+    while (l->pos > 0 && isDelimiter(l->buf[l->pos - 1])) l->pos--;
+    /* Then continue moving over a word */
+    while (l->pos > 0 && !isDelimiter(l->buf[l->pos - 1])) l->pos--;
+    refreshLine(l);
+}
+
+static void linenoiseEditMoveWordRight(struct linenoiseState *l, const isDelimiterFunc isDelimiter) {
+    if (l->pos == l->len) return;
+    /* Move cursor to the right over any delimiters */
+    while (l->pos < l->len && isDelimiter(l->buf[l->pos])) l->pos++;
+    /* Then continue moving over a word */
+    while (l->pos < l->len && !isDelimiter(l->buf[l->pos])) l->pos++;
+    refreshLine(l);
+}
+
+
 /* Move cursor to the start of the line. */
 void linenoiseEditMoveHome(struct linenoiseState *l) {
     if (l->pos != 0) {
@@ -901,20 +944,57 @@ static int linenoiseEdit(int stdin_fd, int stdout_fd, char *buf, size_t buflen,
              * Use two calls to handle slow terminals returning the two
              * chars at different times. */
             if (read(l.ifd,seq,1) == -1) break;
+
+            /* Handle Meta-b / Meta-f directly.
+             * Usually generated by Alt + ←/→ (but not always)
+             */
+            if (seq[0] == 'b') {                 /* ESC b → word left */
+                linenoiseEditMoveWordLeft(&l, isSubWordDelimiter);
+                break;
+            }
+            if (seq[0] == 'f') {                 /* ESC f → word right */
+                linenoiseEditMoveWordRight(&l, isSubWordDelimiter);
+                break;
+            }
+
             if (read(l.ifd,seq+1,1) == -1) break;
 
             /* ESC [ sequences. */
             if (seq[0] == '[') {
                 if (seq[1] >= '0' && seq[1] <= '9') {
-                    /* Extended escape, read additional byte. */
-                    if (read(l.ifd,seq+2,1) == -1) break;
-                    if (seq[2] == '~') {
-                        switch(seq[1]) {
-                        case '3': /* Delete key. */
-                            linenoiseEditDelete(&l);
+                    /* Extended escape, read additional bytes.
+                     * Examples: ESC [1;5C  ESC [3~ */
+                    const int seqBufferMaxLength = 8;
+                    char seqBuffer[seqBufferMaxLength];
+                    int i = 0;
+                    seqBuffer[i++] = seq[1];
+
+                    /* If first param is digit or ';', read more until we see a final in @~ */
+                    char additionalChar;
+                    while (i < seqBufferMaxLength-1 && read(l.ifd, &additionalChar, 1) != -1) {
+                        seqBuffer[i++] = additionalChar;
+                        if (additionalChar >= '@' && additionalChar <= '~') {    /* CSI final byte */
+                            seqBuffer[i] = '\0';
                             break;
                         }
                     }
+
+                    /* The exact key mapping behavior depends on your keyboard/terminal setup */
+                    /* Usually Alt/Ctrl + ← */
+                    if (!strcmp(seqBuffer, "1;5D") || !strcmp(seqBuffer, "1;3D")) {
+                        linenoiseEditMoveWordLeft(&l, isBigWordDelimiter);
+                        break;
+                    }
+                    /* Usually Alt/Ctrl + → */
+                    if (!strcmp(seqBuffer, "1;5C") || !strcmp(seqBuffer, "1;3C")) {
+                        linenoiseEditMoveWordRight(&l, isBigWordDelimiter);
+                        break;
+                    }
+                    /* Usually the `delete` key */
+                    if (!strcmp(seqBuffer, "3~")) {
+                        linenoiseEditDelete(&l);
+                        break;
+                    }
                 } else {
                     switch(seq[1]) {
                     case 'A': /* Up */