feat(rust-cli): implement POSIX §2.6.1 tilde expansion globally

Tilde expansion was previously hard-coded only inside the `cd`
command. It now runs as the first step of `expand_variables`, so every
command that uses variable expansion — `mkdir`, `touch`, `echo`,
`cp`, `mv`, external commands, etc. — gets tilde expansion for free.

Supported forms (per POSIX §2.6.1):

  ~         → $HOME
  ~/path    → $HOME/path
  ~+        → $PWD
  ~+/path   → $PWD/path
  ~-        → $OLDPWD
  ~-/path   → $OLDPWD/path

Not expanded inside single or double quotes ('~' / "~" stay literal).
This is enforced by `quoted_word_to_string` escaping `~` → `\~` in
quoted contexts; `expand_tilde` recognises the escape and emits a
literal `~`.

~user (getpwnam lookup) is not yet implemented; the tilde is left
literal in that case.

The `cd`-specific `~/` handling is removed since it's now redundant.

Test results: 721 passing, 0 failing, 14 ignored (up from 712).

https://claude.ai/code/session_01EMHrh5Jq32pb98KXoSKLA4

Author: claude

impl/rust-cli/src/executable.rs

@@ -333,13 +333,10 @@ impl ExecutableCommand for Command {
                             }
                         }
                     } else if p.starts_with('/') {
-                        // Absolute path
+                        // Absolute path (also handles expanded ~/... since
+                        // tilde expansion in expand_variables already turned
+                        // ~/path into /home/user/path)
                         PathBuf::from(p)
-                    } else if p.starts_with("~/") {
-                        // Home-relative path
-                        let home = dirs::home_dir()
-                            .ok_or_else(|| anyhow::anyhow!("Could not find home directory"))?;
-                        home.join(&p[2..])
                     } else {
                         // Relative to current directory
                         state.root.join(p)

impl/rust-cli/src/parser.rs

@@ -2290,7 +2290,59 @@ fn apply_substring(value: &str, offset: i32, length: Option<usize>) -> String {
     }
 }
 
+/// POSIX §2.6.1 tilde expansion.
+///
+/// Expands an unquoted leading `~` in a word:
+///
+/// - `~` or `~/path`  → `$HOME` / `$HOME/path`
+/// - `~+` or `~+/...` → `$PWD` / `$PWD/...`
+/// - `~-` or `~-/...` → `$OLDPWD` / `$OLDPWD/...`
+///
+/// `~user` is not yet supported (requires getpwnam). An escaped `\~`
+/// (produced by `quoted_word_to_string` for quoted `~`) stays literal.
+fn expand_tilde(input: &str) -> String {
+    // An escaped tilde `\~` means the tilde was inside quotes — leave it.
+    if input.starts_with("\\~") {
+        let mut s = String::with_capacity(input.len());
+        s.push('~');
+        s.push_str(&input[2..]);
+        return s;
+    }
+
+    if !input.starts_with('~') {
+        return input.to_string();
+    }
+
+    // After the `~`, the "prefix" extends until the first `/` or end-of-string.
+    let rest = &input[1..];
+    let (prefix, suffix) = match rest.find('/') {
+        Some(pos) => (&rest[..pos], &rest[pos..]),
+        None => (rest, ""),
+    };
+
+    let replacement = match prefix {
+        "" => std::env::var("HOME").ok(),
+        "+" => std::env::var("PWD").ok(),
+        "-" => std::env::var("OLDPWD").ok(),
+        _ => {
+            // ~user — not implemented yet; leave the tilde literal.
+            return input.to_string();
+        }
+    };
+
+    match replacement {
+        Some(home) => format!("{}{}", home, suffix),
+        None => input.to_string(),
+    }
+}
+
 pub fn expand_variables(input: &str, state: &crate::state::ShellState) -> String {
+    // Tilde expansion (POSIX §2.6.1) happens before variable expansion
+    // and only at the start of a word (the word has already been split by
+    // the tokeniser). An escaped `\~` (produced by quoted_word_to_string
+    // for `'~'` or `"~"`) is left literal.
+    let input = expand_tilde(input);
+
     let mut result = String::new();
     let mut chars = input.chars().peekable();
 
@@ -2400,9 +2452,10 @@ fn quoted_word_to_string(word: &QuotedWord) -> String {
                 if word.quote_type != QuoteType::None {
                     // Escape $ in single quotes so expand_variables() doesn't expand
                     // Escape glob metacharacters (* ? [ {) in all quotes
+                    // Escape ~ in all quotes so tilde expansion stays literal
                     for ch in s.chars() {
                         if (word.quote_type == QuoteType::Single && ch == '$')
-                            || matches!(ch, '*' | '?' | '[' | '{')
+                            || matches!(ch, '*' | '?' | '[' | '{' | '~')
                         {
                             result.push('\\');
                         }

impl/rust-cli/tests/tilde_expansion_tests.rs

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+//! Tests for POSIX §2.6.1 tilde expansion.
+//!
+//! Tilde expansion was previously hard-coded only inside the `cd` command.
+//! It now runs globally via `expand_variables`, so `mkdir ~/foo`,
+//! `echo ~`, `touch ~/bar`, etc. all work.
+
+use anyhow::Result;
+use tempfile::tempdir;
+use vsh::executable::ExecutableCommand;
+use vsh::parser::{expand_variables, parse_command};
+use vsh::state::ShellState;
+
+// -------------------------------------------------------------------------
+// Unit tests for expand_tilde (via expand_variables)
+// -------------------------------------------------------------------------
+
+#[test]
+fn tilde_alone_expands_to_home() {
+    let temp = tempdir().unwrap();
+    let state = ShellState::new(temp.path().to_str().unwrap()).unwrap();
+
+    let home = std::env::var("HOME").unwrap_or_default();
+    assert_eq!(expand_variables("~", &state), home);
+}
+
+#[test]
+fn tilde_slash_path_expands_to_home_slash_path() {
+    let temp = tempdir().unwrap();
+    let state = ShellState::new(temp.path().to_str().unwrap()).unwrap();
+
+    let home = std::env::var("HOME").unwrap_or_default();
+    assert_eq!(
+        expand_variables("~/Documents/foo", &state),
+        format!("{}/Documents/foo", home)
+    );
+}
+
+#[test]
+fn tilde_plus_expands_to_pwd() {
+    let temp = tempdir().unwrap();
+    let state = ShellState::new(temp.path().to_str().unwrap()).unwrap();
+
+    std::env::set_var("PWD", "/some/where");
+    assert_eq!(expand_variables("~+", &state), "/some/where");
+    assert_eq!(
+        expand_variables("~+/subdir", &state),
+        "/some/where/subdir"
+    );
+}
+
+#[test]
+fn tilde_minus_expands_to_oldpwd() {
+    let temp = tempdir().unwrap();
+    let state = ShellState::new(temp.path().to_str().unwrap()).unwrap();
+
+    std::env::set_var("OLDPWD", "/old/dir");
+    assert_eq!(expand_variables("~-", &state), "/old/dir");
+    assert_eq!(expand_variables("~-/file", &state), "/old/dir/file");
+}
+
+#[test]
+fn tilde_not_at_start_stays_literal() {
+    let temp = tempdir().unwrap();
+    let state = ShellState::new(temp.path().to_str().unwrap()).unwrap();
+
+    assert_eq!(expand_variables("foo~bar", &state), "foo~bar");
+}
+
+#[test]
+fn escaped_tilde_stays_literal() {
+    let temp = tempdir().unwrap();
+    let state = ShellState::new(temp.path().to_str().unwrap()).unwrap();
+
+    // `\~` is what quoted_word_to_string produces for '~' or "~"
+    assert_eq!(expand_variables("\\~", &state), "~");
+    assert_eq!(expand_variables("\\~/foo", &state), "~/foo");
+}
+
+#[test]
+fn unknown_tilde_user_stays_literal() {
+    let temp = tempdir().unwrap();
+    let state = ShellState::new(temp.path().to_str().unwrap()).unwrap();
+
+    assert_eq!(
+        expand_variables("~nonexistent_user_xyz", &state),
+        "~nonexistent_user_xyz"
+    );
+}
+
+// -------------------------------------------------------------------------
+// Integration: tilde expansion works in real commands (not just cd)
+// -------------------------------------------------------------------------
+
+#[test]
+fn tilde_expands_in_variable_assignments() -> Result<()> {
+    let temp = tempdir()?;
+    let state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    let home = std::env::var("HOME").unwrap_or_default();
+
+    // Verify tilde expansion works inside commands that use expand_variables
+    let expanded = expand_variables("~/.config/vsh", &state);
+    assert_eq!(expanded, format!("{}/.config/vsh", home));
+
+    Ok(())
+}
+
+#[test]
+fn cd_with_tilde_still_works() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    let home = std::env::var("HOME").unwrap_or_default();
+
+    let cmd = parse_command("cd ~")?;
+    cmd.execute(&mut state)?;
+
+    assert_eq!(
+        state.root,
+        std::fs::canonicalize(&home).unwrap_or_else(|_| std::path::PathBuf::from(&home))
+    );
+    Ok(())
+}