From 3878c83e462635da732ff17d8983bf4ea0bc4501 Mon Sep 17 00:00:00 2001
From: sigoden <sigoden@gmail.com>
Date: Fri, 26 Apr 2024 12:51:13 +0000
Subject: [PATCH 1/3] feat: add features for easily integrating argc as lib

---
 .github/workflows/ci.yaml                     |  17 +-
 Argcfile.sh                                   |   5 +
 Cargo.toml                                    |  49 +-
 examples/multiline.sh                         |   2 +-
 src/argc_value.rs                             |   4 +-
 src/bin/argc/main.rs                          |  62 +-
 src/bin/argc/parallel.rs                      |  16 +-
 src/build.rs                                  |  14 +-
 src/command/mod.rs                            | 116 ++--
 src/compgen.rs                                | 567 ++----------------
 src/lib.rs                                    |  33 +-
 src/matcher.rs                                |  71 ++-
 src/param.rs                                  |   6 +
 src/runtime/mod.rs                            |  90 +++
 src/runtime/navite.rs                         | 177 ++++++
 src/shell.rs                                  | 424 +++++++++++++
 src/utils.rs                                  | 183 +-----
 tests/fixtures.rs                             |   5 +-
 tests/macros.rs                               |  36 +-
 .../integration__compgen__filedir__cd.snap    |   8 +
 ...gration__compgen__filedir__value_name.snap |   5 +
 21 files changed, 1095 insertions(+), 795 deletions(-)
 create mode 100644 src/runtime/mod.rs
 create mode 100644 src/runtime/navite.rs
 create mode 100644 src/shell.rs

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 9cbf67a6..6399a10f 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -43,4 +43,19 @@ jobs:
       run: cargo clippy --all --all-targets
 
     - name: Format
-      run: cargo fmt --all --check
\ No newline at end of file
+      run: cargo fmt --all --check
+
+  features:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust Toolchain Components
+        uses: dtolnay/rust-toolchain@stable
+
+      - uses: Swatinem/rust-cache@v2
+
+      - uses: taiki-e/install-action@cargo-hack
+
+      - run: cargo hack --no-dev-deps check --feature-powerset --depth 2 --lib
\ No newline at end of file
diff --git a/Argcfile.sh b/Argcfile.sh
index 2b698a0d..79cab7e9 100644
--- a/Argcfile.sh
+++ b/Argcfile.sh
@@ -7,6 +7,11 @@ test() {
     cargo test "$@"
 }
 
+# @cmd Test features matrix
+test-features() {
+    cargo hack --no-dev-deps check --feature-powerset --depth 2 --lib
+}
+
 # @cmd Check the project
 # @alias c
 check() {
diff --git a/Cargo.toml b/Cargo.toml
index b488bbef..d63691f0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,23 +11,52 @@ autotests = false
 categories = ["command-line-utilities", "development-tools"]
 keywords = ["cli", "bash", "runner", "arg", "parser"]
 
+[features]
+default = ["application"]
+# Feature required for argc the application. Should be disabled when depending on
+# argc as a library.
+application = [
+    "native-runtime",
+    "eval-bash",
+    "build",
+    "mangen",
+    "completions",
+    "compgen",
+    "export",
+    "wrap-help",
+
+    # deps
+    "num_cpus",
+    "threadpool",
+    "base64",
+]
+native-runtime = ["which"]
+eval = []
+eval-bash = ["eval"]
+build = []
+mangen = ["roff"]
+completions = []
+compgen = ["dirs", "natord"]
+export = ["serde_json", "indexmap/serde"]
+wrap-help = ["textwrap"]
+
 [dependencies]
 anyhow = "1"
 convert_case = "0.6"
-indexmap = { version = "2.1", features = ["serde"] }
+indexmap = { version = "2.1" }
 nom = "7.1"
 either = "1.8"
 serde = { version = "1.0", features = ["derive"] }
-serde_json = { version = "1.0", features = ["preserve_order"] }
-which = "6.0"
+serde_json = { version = "1.0", features = ["preserve_order"], optional = true }
+which = { version = "6.0", optional = true }
 shell-words = "1.1"
-textwrap = "0.16"
-dirs = "5.0"
-num_cpus = "1.16"
-threadpool = "1.8"
-base64 = "0.22"
-natord = "1.0"
-roff = "0.2"
+textwrap = { version = "0.16", optional = true }
+dirs = { version = "5.0", optional = true }
+num_cpus = { version = "1.16", optional = true }
+threadpool = { version = "1.8", optional = true }
+base64 = { version = "0.22", optional = true }
+natord = { version = "1.0", optional = true }
+roff = { version = "0.2", optional = true }
 
 [dev-dependencies]
 insta = "1.30"
diff --git a/examples/multiline.sh b/examples/multiline.sh
index 361b602c..6820fba5 100755
--- a/examples/multiline.sh
+++ b/examples/multiline.sh
@@ -19,4 +19,4 @@
 # are treated as the long description. A line which is not a comment ends the block.
 cmd() { :; }
 
-eval "$(TERM_WIDTH=`tput cols` argc --argc-eval "$0" "$@")"
\ No newline at end of file
+eval "$(TERM_WIDTH=${TERM_WIDTH:-`tput cols`} argc --argc-eval "$0" "$@")"
\ No newline at end of file
diff --git a/src/argc_value.rs b/src/argc_value.rs
index 65436861..d64f90a9 100644
--- a/src/argc_value.rs
+++ b/src/argc_value.rs
@@ -1,5 +1,6 @@
 use indexmap::IndexMap;
 
+#[cfg(feature = "eval-bash")]
 use crate::utils::{
     argc_var_name, escape_shell_words, expand_dotenv, AFTER_HOOK, ARGC_REQUIRE_TOOLS, BEFORE_HOOK,
     VARIABLE_PREFIX,
@@ -25,8 +26,9 @@ pub enum ArgcValue {
     Error((String, i32)),
 }
 
+#[cfg(feature = "eval-bash")]
 impl ArgcValue {
-    pub fn to_shell(values: &[Self]) -> String {
+    pub fn to_bash(values: &[Self]) -> String {
         let mut list = vec![];
         let mut last = String::new();
         let mut exit = false;
diff --git a/src/bin/argc/main.rs b/src/bin/argc/main.rs
index 78df1dcd..a9eebcbb 100644
--- a/src/bin/argc/main.rs
+++ b/src/bin/argc/main.rs
@@ -2,8 +2,8 @@ mod parallel;
 
 use anyhow::{anyhow, bail, Context, Result};
 use argc::{
-    utils::{escape_shell_words, get_current_dir, get_shell_path, is_true_value, termwidth},
-    Shell,
+    utils::{escape_shell_words, is_true_value, ARGC_COMPLETION_SCRIPT_PATH},
+    NativeRuntime, Runtime, Shell,
 };
 use base64::{engine::general_purpose, Engine as _};
 use std::{
@@ -12,7 +12,6 @@ use std::{
     path::{Path, PathBuf},
     process,
 };
-use which::which;
 
 const ARGC_SCRIPT_NAMES: [&str; 6] = [
     "Argcfile.sh",
@@ -38,6 +37,7 @@ fn main() {
 }
 
 fn run() -> Result<i32> {
+    let runtime = NativeRuntime;
     let args: Vec<String> = std::env::args().collect();
     let mut argc_cmd = None;
     if let Some(arg) = args.get(1) {
@@ -65,9 +65,15 @@ fn run() -> Result<i32> {
                     code.push_str(&cmds.join(" "));
                     println!("{code}")
                 } else {
-                    let values = argc::eval(&source, &cmd_args, Some(&args[2]), termwidth())?;
+                    let values = argc::eval(
+                        runtime,
+                        &source,
+                        &cmd_args,
+                        Some(&args[2]),
+                        get_term_width(),
+                    )?;
                     let dir_vars = export_dir_vars(&args[2]);
-                    let code = argc::ArgcValue::to_shell(&values);
+                    let code = argc::ArgcValue::to_bash(&values);
                     let export_vars = export_argc_variables(&code);
                     println!("{dir_vars}{export_vars}{code}")
                 }
@@ -85,7 +91,7 @@ fn run() -> Result<i32> {
             "--argc-build" => {
                 let script_path = &args[2];
                 let (source, args) = parse_script_args(&args[2..])?;
-                let script = argc::build(&source, &args[0])?;
+                let script = argc::build(&source, &args[0], get_term_width())?;
                 if let Some(outpath) = args.get(1) {
                     let script_name = get_script_name(script_path)?;
                     let (outpath, new) = ensure_outpath(outpath, script_name)
@@ -127,7 +133,7 @@ fn run() -> Result<i32> {
                 print!("{}", script);
             }
             "--argc-compgen" => {
-                run_compgen(args.to_vec());
+                run_compgen(runtime, args.to_vec());
             }
             "--argc-export" => {
                 let (source, args) = parse_script_args(&args[2..])?;
@@ -138,13 +144,13 @@ fn run() -> Result<i32> {
                 if args.len() <= 3 {
                     bail!("Usage: argc --argc-parallel <SCRIPT> <ARGS>...");
                 }
-                let shell = get_shell_path()?;
+                let shell = runtime.shell_path()?;
                 let (source, cmd_args) = parse_script_args(&args[2..])?;
                 if !source.contains("--argc-eval") {
                     bail!("Parallel only available for argc based scripts.")
                 }
                 let script_file = args[2].clone();
-                parallel::parallel(&shell, &script_file, &cmd_args[1..])?;
+                parallel::parallel(runtime, &shell, &script_file, &cmd_args[1..])?;
             }
             "--argc-script-path" => {
                 let (_, script_file) =
@@ -152,8 +158,8 @@ fn run() -> Result<i32> {
                 println!("{}", script_file.display());
             }
             "--argc-shell-path" => {
-                let shell = get_shell_path()?;
-                println!("{}", shell.display());
+                let shell = runtime.shell_path()?;
+                println!("{}", shell);
             }
             "--argc-help" => {
                 println!("{}", get_argc_help())
@@ -167,11 +173,11 @@ fn run() -> Result<i32> {
         }
         Ok(0)
     } else {
-        let shell = get_shell_path()?;
+        let shell = runtime.shell_path()?;
         let (script_dir, script_file) = get_script_path(true)
             .ok_or_else(|| anyhow!("Argcfile not found, try `argc --argc-help` for help."))?;
         let mut envs = HashMap::new();
-        if let Some(cwd) = get_current_dir() {
+        if let Some(cwd) = runtime.current_dir() {
             envs.insert("ARGC_PWD".to_string(), escape_shell_words(&cwd));
         }
         let mut command = process::Command::new(shell);
@@ -196,7 +202,7 @@ fn run() -> Result<i32> {
     }
 }
 
-fn run_compgen(mut args: Vec<String>) -> Option<()> {
+fn run_compgen(runtime: NativeRuntime, mut args: Vec<String>) -> Option<()> {
     if args.len() < 6 {
         return None;
     };
@@ -208,8 +214,8 @@ fn run_compgen(mut args: Vec<String>) -> Option<()> {
             }
         } else if let Some(script_file) = search_completion_script(&mut args) {
             args[3] = script_file.to_string_lossy().to_string();
-        } else if let Ok(script_file) = which(&args[4]) {
-            args[3] = script_file.to_string_lossy().to_string();
+        } else if let Some(script_file) = runtime.which(&args[4]) {
+            args[3] = script_file;
         }
     }
     let no_color = std::env::var("NO_COLOR")
@@ -218,13 +224,21 @@ fn run_compgen(mut args: Vec<String>) -> Option<()> {
     let output = if &args[4] == "argc" && (args[3].is_empty() || args[5].starts_with("--argc")) {
         let cmd_args = &args[4..];
         let script = get_argc_script_code();
-        argc::compgen(shell, "", &script, cmd_args, no_color).ok()?
+        argc::compgen(
+            runtime,
+            shell,
+            ARGC_COMPLETION_SCRIPT_PATH,
+            &script,
+            cmd_args,
+            no_color,
+        )
+        .ok()?
     } else if args[3].is_empty() {
         let cmd_args = &args[4..];
-        argc::compgen(shell, "", "# @arg path*", cmd_args, no_color).ok()?
+        argc::compgen(runtime, shell, "", "# @arg path*", cmd_args, no_color).ok()?
     } else {
         let (source, cmd_args) = parse_script_args(&args[3..]).ok()?;
-        argc::compgen(shell, &args[3], &source, &cmd_args[1..], no_color).ok()?
+        argc::compgen(runtime, shell, &args[3], &source, &cmd_args[1..], no_color).ok()?
     };
     if !output.is_empty() {
         println!("{output}");
@@ -321,10 +335,16 @@ fn get_argc_version() -> String {
     format!("{name} {version}")
 }
 
+fn get_term_width() -> Option<usize> {
+    env::var("TERM_WIDTH").ok().and_then(|v| v.parse().ok())
+}
+
 fn export_dir_vars(path: &str) -> String {
     if let (Some(argc_script_dir), Some(cwd)) = (
         get_argc_script_dir(path),
-        env::var("ARGC_PWD").ok().or_else(get_current_dir),
+        env::var("ARGC_PWD")
+            .ok()
+            .or_else(|| env::current_dir().ok().map(|v| v.to_string_lossy().into())),
     ) {
         let cd = if argc_script_dir != cwd {
             format!("cd {}\n", escape_shell_words(&argc_script_dir))
@@ -431,7 +451,7 @@ fn candidate_script_names() -> Vec<String> {
 }
 
 fn search_completion_script(args: &mut Vec<String>) -> Option<PathBuf> {
-    let search_paths = std::env::var("ARGC_COMPLETIONS_PATH").ok()?;
+    let search_paths = env::var("ARGC_COMPLETIONS_PATH").ok()?;
     let cmd = Path::new(&args[4])
         .file_stem()
         .and_then(|v| v.to_str())?
diff --git a/src/bin/argc/parallel.rs b/src/bin/argc/parallel.rs
index 0fee88d0..424f6acb 100644
--- a/src/bin/argc/parallel.rs
+++ b/src/bin/argc/parallel.rs
@@ -1,25 +1,29 @@
 use anyhow::Result;
-use argc::utils::{get_shell_args, path_env_with_exe};
+use argc::{NativeRuntime, Runtime};
 use std::collections::HashMap;
-use std::path::Path;
 use std::process::{self, Command};
 use std::sync::mpsc::channel;
 use threadpool::ThreadPool;
 
 pub const PARALLEL_MODE: &str = "___parallel___";
 
-pub fn parallel(shell: &Path, script_file: &str, args: &[String]) -> Result<()> {
+pub fn parallel(
+    runtime: NativeRuntime,
+    shell: &str,
+    script_file: &str,
+    args: &[String],
+) -> Result<()> {
     let jobs = to_jobs(args);
     let jobs_len = jobs.len();
     let pool = ThreadPool::new(num_cpus::get());
     let (tx, rx) = channel();
-    let path_env = path_env_with_exe();
-    let mut shell_extra_args = get_shell_args(shell);
+    let path_env = runtime.path_env_with_current_exe();
+    let mut shell_extra_args = runtime.shell_args(shell);
     shell_extra_args.push(script_file.to_string());
     shell_extra_args.push(PARALLEL_MODE.to_string());
     for (i, job_args) in jobs.into_iter().enumerate() {
         let tx = tx.clone();
-        let shell = shell.to_path_buf();
+        let shell = shell.to_string();
         let path_env = path_env.clone();
         let shell_extra_args = shell_extra_args.clone();
         pool.execute(move || {
diff --git a/src/build.rs b/src/build.rs
index c3290906..c46a819f 100644
--- a/src/build.rs
+++ b/src/build.rs
@@ -180,9 +180,9 @@ _argc_check_bool() {
     ),
 ];
 
-pub fn build(source: &str, root_name: &str) -> Result<String> {
+pub fn build(source: &str, root_name: &str, wrap_width: Option<usize>) -> Result<String> {
     let cmd = Command::new(source, root_name)?;
-    let output = build_root(&cmd);
+    let output = build_root(&cmd, wrap_width);
     let mut build_block = false;
     let mut insert_at = None;
     let mut newlines = vec![];
@@ -210,8 +210,8 @@ pub fn build(source: &str, root_name: &str) -> Result<String> {
     Ok(newlines.join("\n"))
 }
 
-fn build_root(cmd: &Command) -> String {
-    let command = build_command(cmd);
+fn build_root(cmd: &Command, wrap_width: Option<usize>) -> String {
+    let command = build_command(cmd, wrap_width);
     let dotenv = if let Some(value) = cmd.dotenv() {
         format!("\n    {}", expand_dotenv(value))
     } else {
@@ -273,7 +273,7 @@ _argc_run "$@"
     )
 }
 
-fn build_command(cmd: &Command) -> String {
+fn build_command(cmd: &Command, wrap_width: Option<usize>) -> String {
     let suffix = if cmd.is_root() {
         String::new()
     } else {
@@ -281,7 +281,7 @@ fn build_command(cmd: &Command) -> String {
     };
 
     let usage = {
-        let usage = cmd.render_help(None);
+        let usage = cmd.render_help(wrap_width);
         let usage = usage.trim();
         format!(
             r#"
@@ -313,7 +313,7 @@ _argc_version{suffix}() {{
     let subcmds = cmd
         .subcommands
         .iter()
-        .map(build_command)
+        .map(|v| build_command(v, wrap_width))
         .collect::<Vec<String>>()
         .join("");
 
diff --git a/src/command/mod.rs b/src/command/mod.rs
index 5e46f8bd..783bc26d 100644
--- a/src/command/mod.rs
+++ b/src/command/mod.rs
@@ -5,11 +5,13 @@ use self::names_checker::NamesChecker;
 use self::share_data::ShareData;
 
 use crate::argc_value::ArgcValue;
+#[cfg(feature = "eval")]
 use crate::matcher::Matcher;
-use crate::param::{
-    EnvParam, EnvValue, FlagOptionParam, FlagOptionValue, Param, PositionalParam, PositionalValue,
-};
+use crate::param::{EnvParam, FlagOptionParam, Param, PositionalParam};
+#[cfg(feature = "export")]
+use crate::param::{EnvValue, FlagOptionValue, PositionalValue};
 use crate::parser::{parse, parse_symbol, Event, EventData, EventScope, Position};
+use crate::runtime::Runtime;
 use crate::utils::{
     AFTER_HOOK, BEFORE_HOOK, INTERNAL_SYMBOL, MAIN_NAME, META_AUTHOR, META_COMBINE_SHORTS,
     META_DEFAULT_SUBCOMMAND, META_DOTENV, META_INHERIT_FLAG_OPTIONS, META_REQUIRE_TOOLS,
@@ -64,11 +66,13 @@ impl Command {
         Ok(root)
     }
 
-    pub(crate) fn eval(
+    #[cfg(feature = "eval")]
+    pub(crate) fn eval<T: Runtime>(
         &mut self,
+        runtime: T,
         args: &[String],
         script_path: Option<&str>,
-        term_width: Option<usize>,
+        wrap_width: Option<usize>,
     ) -> Result<Vec<ArgcValue>> {
         if args.is_empty() {
             bail!("Invalid args");
@@ -80,21 +84,22 @@ impl Command {
             } else {
                 &args[3..]
             };
-            let matcher = Matcher::new(self, new_args, false);
+            let matcher = Matcher::new(runtime, self, new_args, false);
             let mut arg_values = matcher.to_arg_values_for_param_fn();
             arg_values.push(ArgcValue::ParamFn(args[2].clone()));
             return Ok(arg_values);
         }
-        let mut matcher = Matcher::new(self, args, false);
+        let mut matcher = Matcher::new(runtime, self, args, false);
         if let Some(script_path) = script_path {
             matcher.set_script_path(script_path)
         }
-        if let Some(term_width) = term_width {
-            matcher.set_term_width(term_width)
+        if let Some(wrap_width) = wrap_width {
+            matcher.set_wrap_width(wrap_width)
         }
         Ok(matcher.to_arg_values())
     }
 
+    #[cfg(feature = "export")]
     pub(crate) fn export(&self) -> CommandValue {
         let mut extra: IndexMap<String, serde_json::Value> = IndexMap::new();
         let require_tools = self.meta_require_tools();
@@ -380,32 +385,6 @@ impl Command {
         self.cmd_paths().join("-")
     }
 
-    pub(crate) fn render_help(&self, term_width: Option<usize>) -> String {
-        let mut output = vec![];
-        if self.version.is_some() {
-            output.push(self.render_version());
-        }
-        if let Some(author) = &self.author {
-            output.push(author.to_string());
-        }
-        if !&self.describe.is_empty() {
-            output.push(wrap_render_block("", &self.describe, term_width));
-        }
-        if !output.is_empty() {
-            output.push(String::new());
-        }
-        output.push(self.render_usage());
-        output.push(String::new());
-        output.extend(self.render_positionals(term_width));
-        output.extend(self.render_flag_options(term_width));
-        output.extend(self.render_subcommands(term_width));
-        output.extend(self.render_envs(term_width));
-        if output.is_empty() {
-            return "\n".to_string();
-        }
-        output.join("\n")
-    }
-
     pub(crate) fn render_version(&self) -> String {
         format!(
             "{} {}",
@@ -679,6 +658,35 @@ impl Command {
             describe,
         ))
     }
+}
+
+#[cfg(any(feature = "build", feature = "eval"))]
+impl Command {
+    pub(crate) fn render_help(&self, wrap_width: Option<usize>) -> String {
+        let mut output = vec![];
+        if self.version.is_some() {
+            output.push(self.render_version());
+        }
+        if let Some(author) = &self.author {
+            output.push(author.to_string());
+        }
+        if !&self.describe.is_empty() {
+            output.push(render_block("", &self.describe, wrap_width));
+        }
+        if !output.is_empty() {
+            output.push(String::new());
+        }
+        output.push(self.render_usage());
+        output.push(String::new());
+        output.extend(self.render_positionals(wrap_width));
+        output.extend(self.render_flag_options(wrap_width));
+        output.extend(self.render_subcommands(wrap_width));
+        output.extend(self.render_envs(wrap_width));
+        if output.is_empty() {
+            return "\n".to_string();
+        }
+        output.join("\n")
+    }
 
     fn render_usage(&self) -> String {
         let mut output = vec!["USAGE:".to_string()];
@@ -701,7 +709,7 @@ impl Command {
         output.join(" ")
     }
 
-    fn render_flag_options(&self, term_width: Option<usize>) -> Vec<String> {
+    fn render_flag_options(&self, wrap_width: Option<usize>) -> Vec<String> {
         let mut output = vec![];
         let default_subcmd = self.find_default_subcommand();
         if self.flag_option_params.is_empty()
@@ -733,12 +741,12 @@ impl Command {
             &mut output,
             list.into_iter().collect(),
             value_size,
-            term_width,
+            wrap_width,
         );
         output
     }
 
-    fn render_positionals(&self, term_width: Option<usize>) -> Vec<String> {
+    fn render_positionals(&self, wrap_width: Option<usize>) -> Vec<String> {
         let mut output = vec![];
         let params = match self.find_default_subcommand() {
             Some(subcmd) => &subcmd.positional_params,
@@ -758,11 +766,11 @@ impl Command {
             .collect();
         value_size += 2;
         output.push("ARGS:".to_string());
-        render_list(&mut output, list, value_size, term_width);
+        render_list(&mut output, list, value_size, wrap_width);
         output
     }
 
-    fn render_envs(&self, term_width: Option<usize>) -> Vec<String> {
+    fn render_envs(&self, wrap_width: Option<usize>) -> Vec<String> {
         let mut output = vec![];
         let params = match self.find_default_subcommand() {
             Some(subcmd) => &subcmd.env_params,
@@ -782,11 +790,11 @@ impl Command {
             .collect();
         value_size += 2;
         output.push("ENVIRONMENTS:".to_string());
-        render_list(&mut output, list, value_size, term_width);
+        render_list(&mut output, list, value_size, wrap_width);
         output
     }
 
-    fn render_subcommands(&self, term_width: Option<usize>) -> Vec<String> {
+    fn render_subcommands(&self, wrap_width: Option<usize>) -> Vec<String> {
         let mut output = vec![];
         if self.subcommands.is_empty() {
             return output;
@@ -803,7 +811,7 @@ impl Command {
             .collect();
         value_size += 2;
         output.push("COMMANDS:".to_string());
-        render_list(&mut output, list, value_size, term_width);
+        render_list(&mut output, list, value_size, wrap_width);
         output
     }
 
@@ -825,6 +833,7 @@ impl Command {
     }
 }
 
+#[cfg(feature = "export")]
 #[derive(Debug, Serialize)]
 pub struct CommandValue {
     pub name: String,
@@ -884,7 +893,7 @@ fn render_list(
     output: &mut Vec<String>,
     list: Vec<(String, String)>,
     value_size: usize,
-    term_width: Option<usize>,
+    wrap_width: Option<usize>,
 ) {
     let mut mapped_list = vec![];
     let multiline = list.iter().any(|(_, describe)| describe.contains('\n'));
@@ -895,11 +904,11 @@ fn render_list(
         } else if multiline {
             format!(
                 "  {value}\n{}\n",
-                wrap_render_block(&" ".repeat(10), &describe, term_width)
+                render_block(&" ".repeat(10), &describe, wrap_width)
             )
         } else {
             let spaces = " ".repeat(value_size - value.len());
-            wrap_render_block(&format!("  {value}{spaces}"), &describe, term_width)
+            render_block(&format!("  {value}{spaces}"), &describe, wrap_width)
         };
         mapped_list.push(item);
     }
@@ -911,12 +920,21 @@ fn render_list(
     }
 }
 
-fn wrap_render_block(name: &str, describe: &str, term_width: Option<usize>) -> String {
-    let size = term_width.unwrap_or(999) - name.len();
+fn render_block(name: &str, describe: &str, wrap_width: Option<usize>) -> String {
+    let size = wrap_width.unwrap_or(999) - name.len();
     let empty = " ".repeat(name.len());
     describe
         .split('\n')
-        .flat_map(|v| textwrap::wrap(v, size))
+        .flat_map(|v| {
+            #[cfg(feature = "wrap-help")]
+            {
+                textwrap::wrap(v, size)
+            }
+            #[cfg(not(feature = "wrap-help"))]
+            {
+                vec![v]
+            }
+        })
         .enumerate()
         .map(|(i, v)| {
             if i == 0 {
diff --git a/src/compgen.rs b/src/compgen.rs
index fcfd78a1..46c56315 100644
--- a/src/compgen.rs
+++ b/src/compgen.rs
@@ -1,21 +1,19 @@
 use crate::command::Command;
 use crate::matcher::Matcher;
-use crate::utils::{get_os, is_quote_char, is_true_value, is_windows_path, run_param_fns};
-use crate::Result;
+use crate::runtime::Runtime;
+use crate::utils::{is_quote_char, is_windows_path, unbalance_quote, ARGC_COMPLETION_SCRIPT_PATH};
+use crate::Shell;
 
-use anyhow::bail;
-use dirs::home_dir;
+use anyhow::{bail, Result};
 use indexmap::IndexMap;
 use std::collections::{HashMap, HashSet};
-use std::env;
 use std::fmt;
-use std::fs;
-use std::path::PathBuf;
 use std::str::FromStr;
 
 const FILE_PROTO: &str = "file://";
 
-pub fn compgen(
+pub fn compgen<T: Runtime>(
+    runtime: T,
     shell: Shell,
     script_path: &str,
     script_content: &str,
@@ -50,7 +48,7 @@ pub fn compgen(
             })
             .collect()
     };
-    let matcher = Matcher::new(&cmd, &new_args, true);
+    let matcher = Matcher::new(runtime, &cmd, &new_args, true);
     let compgen_values = matcher.compgen(shell);
     let mut default_nospace = unbalance.is_some();
     let mut prefix = unbalance.map(|v| v.to_string()).unwrap_or_default();
@@ -97,15 +95,15 @@ pub fn compgen(
     let mut argc_filter = last.to_string();
     let mut argc_suffix = String::new();
     let mut argc_cd = None;
-    if let Some(fn_name) = argc_fn {
-        let output = if script_path.is_empty() {
+    if let Some(func) = argc_fn {
+        let output = if script_path == ARGC_COMPLETION_SCRIPT_PATH {
             // complete for argc
             let mut values = vec![];
-            if fn_name == "_choice_completion" {
+            if func == "_choice_completion" {
                 if new_args.len() == 3 {
                     values.extend(Shell::list().map(|v| v.name().to_string()))
                 }
-            } else if fn_name == "_choice_compgen" {
+            } else if func == "_choice_compgen" {
                 if new_args.len() == 3 {
                     values.extend(Shell::list().map(|v| v.name().to_string()))
                 } else {
@@ -113,14 +111,17 @@ pub fn compgen(
                 }
             }
             Some(values.join("\n"))
-        } else {
+        } else if !script_path.is_empty() {
             let mut envs = HashMap::new();
             envs.insert("ARGC_COMPGEN".into(), "1".into());
-            envs.insert("ARGC_OS".into(), get_os());
+            envs.insert("ARGC_OS".into(), runtime.os());
             envs.insert("ARGC_CWORD".into(), argc_filter.clone());
             envs.insert("ARGC_LAST_ARG".into(), last_arg.to_string());
-            run_param_fns(script_path, &[fn_name.as_str()], &new_args, envs)
-                .map(|output| output[0].clone())
+            runtime
+                .exec_bash_functions(script_path, &[func.as_str()], &new_args, envs)
+                .and_then(|output| output.first().cloned())
+        } else {
+            None
         };
         if let Some(output) = output.and_then(|v| if v.is_empty() { None } else { Some(v) }) {
             for line in output.trim().split('\n').map(|v| v.trim()) {
@@ -179,18 +180,30 @@ pub fn compgen(
         candidates = prepend_candidates;
     }
 
+    let need_description = shell.need_description(runtime);
+
     let mut candidates: Vec<CandidateValue> = candidates
         .into_iter()
         .map(|(value, (description, nospace, comp_color))| {
+            let description = if need_description {
+                description
+            } else {
+                String::new()
+            };
             (value, description, nospace, comp_color)
         })
         .collect();
 
     if !shell.is_generic() {
         if let Some(path_value) = argc_value.and_then(|v| convert_arg_value(&v)) {
-            if let Some((value_prefix, value_filter, more_candidates)) =
-                path_value.compgen(shell, &argc_filter, &argc_suffix, &argc_cd, default_nospace)
-            {
+            if let Some((value_prefix, value_filter, more_candidates)) = path_value.compgen(
+                runtime,
+                shell,
+                &argc_filter,
+                &argc_suffix,
+                &argc_cd,
+                default_nospace,
+            ) {
                 if candidates.is_empty() || value_prefix.is_empty() {
                     argc_prefix = format!("{argc_prefix}{value_prefix}");
                     argc_filter = value_filter;
@@ -205,7 +218,7 @@ pub fn compgen(
         }
     }
 
-    let break_chars = shell.need_break_chars(&argc_prefix);
+    let break_chars = shell.need_break_chars(runtime, &argc_prefix);
     if !break_chars.is_empty() {
         let prefix = format!("{}{}", argc_prefix, argc_filter);
         let prefix = match unbalance_quote(&prefix) {
@@ -242,356 +255,10 @@ pub fn compgen(
     Ok(values.join("\n"))
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Shell {
-    Bash,
-    Elvish,
-    Fish,
-    Generic,
-    Nushell,
-    Powershell,
-    Xonsh,
-    Zsh,
-    Tcsh,
-}
-
-impl FromStr for Shell {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        match s {
-            "bash" => Ok(Self::Bash),
-            "elvish" => Ok(Self::Elvish),
-            "fish" => Ok(Self::Fish),
-            "generic" => Ok(Self::Generic),
-            "nushell" => Ok(Self::Nushell),
-            "powershell" => Ok(Self::Powershell),
-            "xonsh" => Ok(Self::Xonsh),
-            "zsh" => Ok(Self::Zsh),
-            "tcsh" => Ok(Self::Tcsh),
-            _ => bail!(
-                "The provided shell is either invalid or missing, must be one of {}",
-                Shell::list_names(),
-            ),
-        }
-    }
-}
-
 pub(crate) type CandidateValue = (String, String, bool, CompColor); // value, description, nospace, comp_color
 
-impl Shell {
-    pub fn list() -> [Shell; 8] {
-        [
-            Shell::Bash,
-            Shell::Elvish,
-            Shell::Fish,
-            Shell::Nushell,
-            Shell::Powershell,
-            Shell::Xonsh,
-            Shell::Zsh,
-            Shell::Tcsh,
-        ]
-    }
-
-    pub fn list_names() -> String {
-        Shell::list()
-            .iter()
-            .map(|v| v.name())
-            .collect::<Vec<&str>>()
-            .join(",")
-    }
-
-    pub fn name(&self) -> &str {
-        match self {
-            Shell::Bash => "bash",
-            Shell::Elvish => "elvish",
-            Shell::Fish => "fish",
-            Shell::Generic => "generic",
-            Shell::Nushell => "nushell",
-            Shell::Powershell => "powershell",
-            Shell::Xonsh => "xonsh",
-            Shell::Zsh => "zsh",
-            Shell::Tcsh => "tcsh",
-        }
-    }
-
-    pub fn is_generic(&self) -> bool {
-        *self == Shell::Generic
-    }
-
-    pub(crate) fn convert_candidates(
-        &self,
-        candidates: Vec<CandidateValue>,
-        prefix: &str,
-        filter: &str,
-        no_color: bool,
-    ) -> Vec<String> {
-        match self {
-            Shell::Bash => {
-                let prefix_unbalance = unbalance_quote(prefix);
-                let values: Vec<&str> = candidates.iter().map(|(v, _, _, _)| v.as_str()).collect();
-                let mut add_space_to_first_candidate = false;
-                if values.len() == 1 {
-                    let space = if candidates[0].2 { "" } else { " " };
-                    let mut value = format!("{prefix}{}", candidates[0].0);
-                    if prefix_unbalance.is_none() {
-                        value = self.escape(&value);
-                    }
-                    return vec![format!("{value}{space}")];
-                } else if let Some(common) = common_prefix(&values) {
-                    if common != filter {
-                        if common != "--" {
-                            let mut value = format!("{prefix}{common}");
-                            if prefix_unbalance.is_none() {
-                                value = self.escape(&value);
-                            }
-                            return vec![value];
-                        }
-                    } else if !prefix.is_empty() && !common.starts_with(prefix) {
-                        add_space_to_first_candidate = true;
-                    }
-                }
-                candidates
-                    .into_iter()
-                    .enumerate()
-                    .map(|(i, (value, description, nospace, _comp_color))| {
-                        let mut new_value = if prefix_unbalance.is_none() {
-                            self.escape(&value)
-                        } else {
-                            value
-                        };
-                        if i == 0 && add_space_to_first_candidate {
-                            new_value = format!(" {}", new_value)
-                        };
-                        let description = self.comp_description(&description, "(", ")");
-                        if description.is_empty() {
-                            let space = if nospace { "" } else { " " };
-                            format!("{new_value}{space}")
-                        } else {
-                            format!("{new_value} {description}")
-                        }
-                    })
-                    .collect::<Vec<String>>()
-            }
-            Shell::Elvish | Shell::Powershell => candidates
-                .into_iter()
-                .map(|(value, description, nospace, comp_color)| {
-                    let new_value = self.combine_value(prefix, &value);
-                    let display = if value.is_empty() { " ".into() } else { value };
-                    let description = self.comp_description(&description, "", "");
-                    let space: &str = if nospace { "0" } else { "1" };
-                    let color = self.color(comp_color, no_color);
-                    format!("{new_value}\t{space}\t{display}\t{description}\t{color}")
-                })
-                .collect::<Vec<String>>(),
-            Shell::Fish => candidates
-                .into_iter()
-                .map(|(value, description, _nospace, _comp_color)| {
-                    let new_value = self.combine_value(prefix, &value);
-                    let description = self.comp_description(&description, "\t", "");
-                    format!("{new_value}{description}")
-                })
-                .collect::<Vec<String>>(),
-            Shell::Generic => candidates
-                .into_iter()
-                .map(|(value, description, nospace, comp_color)| {
-                    let comp_color = format!("\t/color:{}", comp_color.ser());
-                    let description = self.comp_description(&description, "\t", "");
-                    let space: &str = if nospace { "\0" } else { "" };
-                    format!("{value}{space}{comp_color}{description}")
-                })
-                .collect::<Vec<String>>(),
-            Shell::Nushell => candidates
-                .into_iter()
-                .map(|(value, description, nospace, _)| {
-                    let new_value = self.combine_value(prefix, &value);
-                    let space = if nospace { "" } else { " " };
-                    let description = self.comp_description(&description, "\t", "");
-                    format!("{new_value}{space}{description}")
-                })
-                .collect::<Vec<String>>(),
-            Shell::Xonsh => candidates
-                .into_iter()
-                .map(|(value, description, nospace, _)| {
-                    let mut new_value = format!("{prefix}{value}");
-                    if unbalance_quote(prefix).is_none() {
-                        let escaped_new_value = self.escape(&new_value);
-                        if escaped_new_value.ends_with("\\'")
-                            && !escaped_new_value.ends_with("\\\\'")
-                        {
-                            new_value = format!(
-                                "{}\\'",
-                                &escaped_new_value.as_str()[0..escaped_new_value.len() - 1]
-                            );
-                        } else {
-                            new_value = escaped_new_value
-                        }
-                    } else if new_value.ends_with('\\') && !new_value.ends_with("\\\\") {
-                        new_value.push('\\')
-                    }
-                    let display = if value.is_empty() { " ".into() } else { value };
-                    let description = self.comp_description(&description, "", "");
-                    let space: &str = if nospace { "0" } else { "1" };
-                    format!("{new_value}\t{space}\t{display}\t{description}")
-                })
-                .collect::<Vec<String>>(),
-            Shell::Zsh => candidates
-                .into_iter()
-                .map(|(value, description, nospace, comp_color)| {
-                    let new_value = if let Some((ch, i)) = unbalance_quote(prefix) {
-                        if i == 0 {
-                            format!("{}{value}", &prefix[1..])
-                        } else {
-                            format!(
-                                "{}{ch}{}{value}",
-                                self.escape(&prefix[0..i]),
-                                &prefix[i + 1..]
-                            )
-                        }
-                    } else {
-                        self.escape(&format!("{prefix}{value}"))
-                    };
-
-                    let new_value = new_value.replace(':', "\\:");
-                    let display = value.replace(':', "\\:");
-                    let description = self.comp_description(&description, ":", "");
-                    let color = self.color(comp_color, no_color);
-                    let space = if nospace { "" } else { " " };
-                    format!("{new_value}{space}\t{display}{description}\t{value}\t{color}")
-                })
-                .collect::<Vec<String>>(),
-            Shell::Tcsh => {
-                if candidates.len() == 1 {
-                    let new_value =
-                        sanitize_tcsh_value(&self.combine_value(prefix, &candidates[0].0));
-                    return vec![new_value];
-                }
-                candidates
-                    .into_iter()
-                    .map(|(value, description, _, _)| {
-                        let new_value = sanitize_tcsh_value(&self.combine_value(prefix, &value));
-                        let description = self.comp_description(&description, " (", ")");
-                        let description = description.replace(' ', "⠀");
-                        format!("{new_value}{description}")
-                    })
-                    .collect::<Vec<String>>()
-            }
-        }
-    }
-
-    pub(crate) fn with_description(&self) -> bool {
-        match env::var("ARGC_COMPGEN_DESCRIPTION") {
-            Ok(v) => is_true_value(&v),
-            Err(_) => true,
-        }
-    }
-
-    pub(crate) fn escape(&self, value: &str) -> String {
-        match self {
-            Shell::Bash => escape_chars(value, self.need_escape_chars(), "\\"),
-            Shell::Nushell | Shell::Powershell | Shell::Xonsh => {
-                if contains_chars(value, self.need_escape_chars()) {
-                    format!("'{value}'")
-                } else {
-                    value.into()
-                }
-            }
-            Shell::Zsh => escape_chars(value, self.need_escape_chars(), "\\\\"),
-            _ => value.into(),
-        }
-    }
-
-    pub(crate) fn color(&self, comp_color: CompColor, no_color: bool) -> String {
-        match self {
-            Shell::Elvish => {
-                if no_color {
-                    return "default".into();
-                }
-                comp_color.style()
-            }
-            Shell::Powershell | Shell::Zsh => {
-                if no_color {
-                    return "39".into();
-                }
-                comp_color.ansi_code()
-            }
-            _ => String::new(),
-        }
-    }
-
-    pub(crate) fn redirect_symbols(&self) -> Vec<&str> {
-        match self {
-            Shell::Nushell => vec![],
-            _ => vec!["<", ">"],
-        }
-    }
-
-    fn is_unix_only(&self) -> bool {
-        matches!(self, Shell::Bash | Shell::Fish | Shell::Zsh | Shell::Tcsh)
-    }
-
-    fn is_windows_mode(&self) -> bool {
-        if cfg!(windows) {
-            !self.is_unix_only()
-        } else {
-            false
-        }
-    }
-
-    fn need_escape_chars(&self) -> &str {
-        match self {
-            Shell::Bash => r#"()<>"'` !#$&;\|"#,
-            Shell::Nushell => r#"()[]{}"'` #$;|"#,
-            Shell::Powershell => r#"()<>[]{}"'` #$&;@|"#,
-            Shell::Xonsh => r#"()<>[]{}!"'` #&;|"#,
-            Shell::Zsh => r#"()<>[]"'` !#$&*;?\|"#,
-            _ => "",
-        }
-    }
-
-    fn need_break_chars(&self, last_arg: &str) -> Vec<char> {
-        if last_arg.starts_with(is_quote_char) {
-            return vec![];
-        }
-        match self {
-            Shell::Bash => match env::var("COMP_WORDBREAKS") {
-                Ok(v) => [':', '=', '@']
-                    .iter()
-                    .filter(|c| v.contains(**c))
-                    .copied()
-                    .collect(),
-                Err(_) => [':', '=', '@'].to_vec(),
-            },
-            Shell::Powershell => vec![','],
-            _ => vec![],
-        }
-    }
-
-    fn need_expand_tilde(&self) -> bool {
-        self.is_windows_mode() && self == &Self::Powershell
-    }
-
-    fn combine_value(&self, prefix: &str, value: &str) -> String {
-        let mut new_value = format!("{prefix}{value}");
-        if unbalance_quote(prefix).is_none() {
-            new_value = self.escape(&new_value);
-        }
-        new_value
-    }
-
-    fn comp_description(&self, description: &str, prefix: &str, suffix: &str) -> String {
-        if description.is_empty() || !self.with_description() {
-            String::new()
-        } else {
-            format!("{prefix}{}{suffix}", truncate_description(description))
-        }
-    }
-}
-
-fn sanitize_tcsh_value(value: &str) -> String {
-    value.replace(' ', "⠀")
-}
-
+/// (value, description, nospace, color)
+pub(crate) type CompItem = (String, String, bool, CompColor);
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct CompColor {
     pub(crate) code: ColorCode,
@@ -779,20 +446,22 @@ pub(crate) struct ArgcPathValue {
 }
 
 impl ArgcPathValue {
-    fn compgen(
+    fn compgen<T: Runtime>(
         &self,
+        runtime: T,
         shell: Shell,
         value: &str,
         suffix: &str,
         cd: &Option<String>,
         default_nospace: bool,
     ) -> Option<(String, String, Vec<CandidateValue>)> {
-        let is_windows_mode = shell.is_windows_mode();
-        let need_expand_tilde = shell.need_expand_tilde();
+        let is_windows_mode = shell.is_windows_mode(runtime);
+        let need_expand_tilde = shell.need_expand_tilde(runtime);
         let is_file_proto = value.starts_with(FILE_PROTO);
         let (search_dir, filter, prefix) =
-            self.resolve_path(value, cd, is_windows_mode, need_expand_tilde)?;
-        if !search_dir.is_dir() {
+            self.resolve_path(runtime, value, cd, is_windows_mode, need_expand_tilde)?;
+        let (is_dir, _, _) = runtime.metadata(&search_dir)?;
+        if !is_dir {
             return None;
         }
 
@@ -823,19 +492,10 @@ impl ArgcPathValue {
             ("", "/")
         };
 
-        #[cfg(windows)]
-        let path_exts: Vec<String> = env::var("PATHEXT")
-            .unwrap_or(".COM;.EXE;.BAT;.CMD".into())
-            .split(';')
-            .filter(|v| !v.is_empty())
-            .map(|v| v.to_lowercase())
-            .collect();
-
         let mut output = vec![];
 
-        for entry in (fs::read_dir(&search_dir).ok()?).flatten() {
-            let path = entry.path();
-            let file_name = entry.file_name().to_string_lossy().to_string();
+        for file_name in runtime.read_dir(&search_dir)? {
+            let path = runtime.join_path(&search_dir, &[&file_name]);
             if !file_name.starts_with(&filter) {
                 continue;
             }
@@ -846,19 +506,10 @@ impl ArgcPathValue {
                 continue;
             };
 
-            let mut meta = match fs::symlink_metadata(&path) {
-                Ok(v) => v,
-                Err(_) => continue,
+            let (is_dir, is_symlink, is_executable) = match runtime.metadata(&path) {
+                Some(v) => v,
+                _ => continue,
             };
-            let is_symlink = meta.is_symlink();
-
-            if is_symlink {
-                meta = match fs::metadata(&path) {
-                    Ok(v) => v,
-                    Err(_) => continue,
-                };
-            }
-            let is_dir = meta.is_dir();
             if !is_dir && self.is_dir {
                 continue;
             }
@@ -881,22 +532,10 @@ impl ArgcPathValue {
                 CompColor::of_dir()
             } else if is_symlink {
                 CompColor::of_symlink()
+            } else if is_executable {
+                CompColor::of_file_exe()
             } else {
-                #[cfg(not(windows))]
-                let is_executable = {
-                    use std::os::unix::fs::PermissionsExt;
-                    meta.permissions().mode() & 0o111 != 0
-                };
-                #[cfg(windows)]
-                let is_executable = {
-                    let new_file_name = file_name.to_lowercase();
-                    path_exts.iter().any(|v| new_file_name.ends_with(v))
-                };
-                if is_executable {
-                    CompColor::of_file_exe()
-                } else {
-                    CompColor::of_file()
-                }
+                CompColor::of_file()
             };
             let nospace = if default_nospace { true } else { is_dir };
             output.push((path_value, String::new(), nospace, comp_color))
@@ -907,13 +546,14 @@ impl ArgcPathValue {
         Some((prefix, filter, output))
     }
 
-    fn resolve_path(
+    fn resolve_path<T: Runtime>(
         &self,
+        runtime: T,
         value: &str,
         cd: &Option<String>,
         is_windows_mode: bool,
         need_expand_tilde: bool,
-    ) -> Option<(PathBuf, String, String)> {
+    ) -> Option<(String, String, String)> {
         let is_home = value == "~";
         let is_file_proto = value.starts_with(FILE_PROTO);
         let (value, sep, home_p, cwd_p) = if is_windows_mode && !is_file_proto {
@@ -947,17 +587,16 @@ impl ArgcPathValue {
                     (value.to_string(), 0, FILE_PROTO.into())
                 }
             } else {
-                let mut cwd = env::current_dir().ok()?;
+                let mut cwd = runtime.current_dir()?;
                 if let Some(cd) = cd {
-                    cwd = cwd.join(cd).canonicalize().ok()?;
+                    cwd = runtime.chdir(&cwd, cd)?;
                 }
-                let cwd_s = cwd.to_string_lossy();
-                let trims = cwd_s.len() + 1;
-                let new_value = format!("{}{sep}{value}", cwd_s).replace('\\', "/");
+                let trims = cwd.len() + 1;
+                let new_value = format!("{}{sep}{value}", cwd).replace('\\', "/");
                 (new_value, trims, FILE_PROTO.into())
             }
         } else if is_home || value.starts_with(home_p) {
-            let home = home_dir()?;
+            let home = dirs::home_dir()?;
             let home_s = home.to_string_lossy();
             let path_s = if is_home {
                 format!("{home_s}{sep}")
@@ -990,13 +629,12 @@ impl ArgcPathValue {
             } else {
                 (value.clone(), "")
             };
-            let mut cwd = env::current_dir().ok()?;
+            let mut cwd = runtime.current_dir()?;
             if let Some(cd) = cd {
-                cwd = cwd.join(cd).canonicalize().ok()?;
+                cwd = runtime.chdir(&cwd, cd)?;
             }
-            let cwd_s = cwd.to_string_lossy();
-            let new_value = format!("{}{sep}{new_value}", cwd_s);
-            let trims = cwd_s.len() + 1;
+            let new_value = format!("{}{sep}{new_value}", cwd);
+            let trims = cwd.len() + 1;
             (new_value, trims, prefix.to_string())
         };
         let (path, filter) = if new_value.ends_with(sep) {
@@ -1008,7 +646,7 @@ impl ArgcPathValue {
             (format!("{parent}{sep}"), filter.into())
         };
         let prefix = format!("{prefix}{}", &path[trims..]);
-        Some((PathBuf::from(path), filter, prefix))
+        Some((path, filter, prefix))
     }
 }
 
@@ -1068,78 +706,6 @@ fn parse_candidate_value(input: &str) -> CandidateValue {
     (value, description, nospace, comp_color)
 }
 
-fn truncate_description(description: &str) -> String {
-    let max_width = 80;
-    let mut description = description.trim().replace('\t', "");
-    if description.starts_with('(') && description.ends_with(')') {
-        description = description
-            .trim_start_matches('(')
-            .trim_end_matches(')')
-            .to_string();
-    }
-    if description.chars().count() < max_width {
-        description
-    } else {
-        let truncated: String = description.chars().take(max_width).collect();
-        format!("{}...", truncated)
-    }
-}
-
-fn unbalance_quote(value: &str) -> Option<(char, usize)> {
-    let mut balance = None;
-    for (i, c) in value.chars().enumerate() {
-        match balance {
-            Some((c_, _)) => {
-                if c == c_ {
-                    balance = None
-                }
-            }
-            None => {
-                if is_quote_char(c) {
-                    balance = Some((c, i))
-                }
-            }
-        }
-    }
-    balance
-}
-
-fn common_prefix(strings: &[&str]) -> Option<String> {
-    if strings.is_empty() {
-        return None;
-    }
-    let mut prefix = String::new();
-    for (i, c) in strings[0].chars().enumerate() {
-        for s in &strings[1..] {
-            if i >= s.len() || s.chars().nth(i) != Some(c) {
-                if prefix.is_empty() {
-                    return None;
-                }
-                return Some(prefix);
-            }
-        }
-        prefix.push(c);
-    }
-    if prefix.is_empty() {
-        return None;
-    }
-    Some(prefix)
-}
-
-fn escape_chars(value: &str, need_escape: &str, for_escape: &str) -> String {
-    let chars: Vec<char> = need_escape.chars().collect();
-    value
-        .chars()
-        .map(|c| {
-            if chars.contains(&c) {
-                format!("{for_escape}{c}")
-            } else {
-                c.to_string()
-            }
-        })
-        .collect()
-}
-
 fn mod_quote(filter: &mut String, prefix: &mut String, default_nospace: &mut bool) {
     if filter.starts_with(is_quote_char) {
         prefix.push_str(&filter[0..1]);
@@ -1148,11 +714,6 @@ fn mod_quote(filter: &mut String, prefix: &mut String, default_nospace: &mut boo
     *filter = filter.trim_matches(is_quote_char).to_string();
 }
 
-fn contains_chars(value: &str, chars: &str) -> bool {
-    let value_chars: Vec<char> = value.chars().collect();
-    chars.chars().any(|v| value_chars.contains(&v))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/lib.rs b/src/lib.rs
index aca0bc7a..abf5abf5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,33 +1,56 @@
 mod argc_value;
+#[cfg(feature = "build")]
 mod build;
 mod command;
+#[cfg(feature = "compgen")]
 mod compgen;
+#[cfg(feature = "completions")]
 mod completions;
+#[cfg(feature = "mangen")]
 mod mangen;
+#[cfg(any(feature = "eval", feature = "compgen"))]
 mod matcher;
 mod param;
 mod parser;
+mod runtime;
+#[cfg(any(feature = "compgen", feature = "completions"))]
+mod shell;
 pub mod utils;
 
 use anyhow::Result;
 pub use argc_value::ArgcValue;
+#[cfg(feature = "build")]
 pub use build::build;
+#[cfg(feature = "export")]
 pub use command::CommandValue;
-pub use compgen::{compgen, Shell};
+#[cfg(feature = "compgen")]
+pub use compgen::compgen;
+#[cfg(feature = "completions")]
 pub use completions::generate_completions;
+#[cfg(feature = "mangen")]
 pub use mangen::mangen;
-pub use param::{ChoiceValue, DefaultValue, EnvValue, FlagOptionValue, PositionalValue};
+pub use param::{ChoiceValue, DefaultValue};
+#[cfg(feature = "export")]
+pub use param::{EnvValue, FlagOptionValue, PositionalValue};
+#[cfg(feature = "native-runtime")]
+pub use runtime::navite::NativeRuntime;
+pub use runtime::Runtime;
+#[cfg(any(feature = "compgen", feature = "completions"))]
+pub use shell::Shell;
 
-pub fn eval(
+#[cfg(feature = "eval")]
+pub fn eval<T: Runtime>(
+    runtime: T,
     script_content: &str,
     args: &[String],
     script_path: Option<&str>,
-    term_width: Option<usize>,
+    wrap_width: Option<usize>,
 ) -> Result<Vec<ArgcValue>> {
     let mut cmd = command::Command::new(script_content, &args[0])?;
-    cmd.eval(args, script_path, term_width)
+    cmd.eval(runtime, args, script_path, wrap_width)
 }
 
+#[cfg(feature = "export")]
 pub fn export(source: &str, root_name: &str) -> Result<CommandValue> {
     let cmd = command::Command::new(source, root_name)?;
     Ok(cmd.export())
diff --git a/src/matcher.rs b/src/matcher.rs
index 24ed2568..b86c865b 100644
--- a/src/matcher.rs
+++ b/src/matcher.rs
@@ -5,19 +5,22 @@ use std::collections::{HashMap, HashSet};
 use crate::{
     argc_value::ArgcValue,
     command::{Command, SymbolParam},
-    compgen::CompColor,
     param::{ChoiceValue, FlagOptionParam, Param, ParamData, PositionalParam},
-    utils::{
-        all_envs, argc_var_name, get_os, is_true_value, load_dotenv, run_param_fns,
-        META_COMBINE_SHORTS,
-    },
+    runtime::Runtime,
+    utils::{argc_var_name, is_true_value, META_COMBINE_SHORTS},
+};
+
+#[cfg(feature = "compgen")]
+use crate::{
+    compgen::{CompColor, CompItem},
     Shell,
 };
 
 use either::Either;
 use indexmap::{IndexMap, IndexSet};
 
-pub(crate) struct Matcher<'a, 'b> {
+pub(crate) struct Matcher<'a, 'b, T> {
+    runtime: T,
     cmds: Vec<&'a Command>,
     cmd_arg_indexes: Vec<usize>,
     args: &'b [String],
@@ -29,7 +32,7 @@ pub(crate) struct Matcher<'a, 'b> {
     choice_fns: HashSet<&'a str>,
     script_path: Option<String>,
     envs: HashMap<String, String>,
-    term_width: Option<usize>,
+    wrap_width: Option<usize>,
     split_last_arg_at: Option<usize>,
     comp_option: Option<&'a str>,
 }
@@ -70,8 +73,13 @@ pub(crate) enum MatchError {
     NoFlagValue(usize, String),
 }
 
-impl<'a, 'b> Matcher<'a, 'b> {
-    pub(crate) fn new(root_cmd: &'a Command, args: &'b [String], compgen: bool) -> Self {
+impl<'a, 'b, T: Runtime> Matcher<'a, 'b, T> {
+    pub(crate) fn new(
+        runtime: T,
+        root_cmd: &'a Command,
+        args: &'b [String],
+        compgen: bool,
+    ) -> Self {
         let combine_shorts = root_cmd.has_metadata(META_COMBINE_SHORTS);
         let mut cmds: Vec<&'a Command> = vec![root_cmd];
         let mut cmd_level = 0;
@@ -345,14 +353,17 @@ impl<'a, 'b> Matcher<'a, 'b> {
 
         let last_cmd = *cmds.last().unwrap();
 
-        let mut envs = all_envs();
-        envs.extend(root_cmd.dotenv().and_then(load_dotenv).unwrap_or_default());
+        let mut envs = runtime.env_vars();
+        if let Some(dot_envs) = root_cmd.dotenv().and_then(|v| runtime.load_dotenv(v)) {
+            envs.extend(dot_envs)
+        }
 
         for param in &last_cmd.env_params {
             add_param_choice_fn(&mut choice_fns, param)
         }
 
         Self {
+            runtime,
             cmds,
             cmd_arg_indexes,
             args,
@@ -363,7 +374,7 @@ impl<'a, 'b> Matcher<'a, 'b> {
             arg_comp,
             choice_fns,
             script_path: None,
-            term_width: None,
+            wrap_width: None,
             split_last_arg_at,
             comp_option,
             envs,
@@ -374,10 +385,11 @@ impl<'a, 'b> Matcher<'a, 'b> {
         self.script_path = Some(script_path.to_string());
     }
 
-    pub(crate) fn set_term_width(&mut self, term_width: usize) {
-        self.term_width = Some(term_width);
+    pub(crate) fn set_wrap_width(&mut self, wrap_width: usize) {
+        self.wrap_width = Some(wrap_width);
     }
 
+    #[cfg(feature = "eval")]
     pub(crate) fn to_arg_values(&self) -> Vec<ArgcValue> {
         let bind_envs = self.build_bind_envs();
         if let Some(err) = self.validate(&bind_envs) {
@@ -401,6 +413,7 @@ impl<'a, 'b> Matcher<'a, 'b> {
         output
     }
 
+    #[cfg(feature = "eval")]
     pub(crate) fn to_arg_values_for_param_fn(&self) -> Vec<ArgcValue> {
         let bind_envs = self.build_bind_envs();
         let mut output: Vec<ArgcValue> = self.to_arg_values_base(&bind_envs);
@@ -425,6 +438,7 @@ impl<'a, 'b> Matcher<'a, 'b> {
         output
     }
 
+    #[cfg(feature = "compgen")]
     pub(crate) fn compgen(&self, shell: Shell) -> Vec<CompItem> {
         let redirect_symbols = shell.redirect_symbols();
         if self
@@ -527,6 +541,7 @@ impl<'a, 'b> Matcher<'a, 'b> {
         self.split_last_arg_at
     }
 
+    #[cfg(feature = "eval")]
     fn to_arg_values_base<'x>(&'x self, bind_envs: &BindEnvs<'a, 'x>) -> Vec<ArgcValue> {
         let mut output = vec![];
         let root_cmd = self.cmds[0];
@@ -604,6 +619,7 @@ impl<'a, 'b> Matcher<'a, 'b> {
         output
     }
 
+    #[cfg(feature = "eval")]
     fn build_bind_envs<'x: 'a>(&'x self) -> BindEnvs<'a, 'x> {
         let cmds_len = self.cmds.len();
         let last_cmd = self.last_cmd();
@@ -630,9 +646,10 @@ impl<'a, 'b> Matcher<'a, 'b> {
         bind_envs
     }
 
+    #[cfg(feature = "eval")]
     fn validate<'x>(&'x self, bind_envs: &BindEnvs<'a, 'x>) -> Option<MatchError> {
         let cmds_len = self.cmds.len();
-        let choices_fn_values = self.run_choices_fns(bind_envs).unwrap_or_default();
+        let choices_fn_values = self.execute_choices_fns(bind_envs).unwrap_or_default();
         for level in 0..cmds_len {
             let flag_option_args = &self.flag_option_args[level];
             let cmd = self.cmds[level];
@@ -874,7 +891,8 @@ impl<'a, 'b> Matcher<'a, 'b> {
         None
     }
 
-    fn run_choices_fns<'x>(
+    #[cfg(feature = "eval")]
+    fn execute_choices_fns<'x>(
         &'x self,
         bind_envs: &BindEnvs<'a, 'x>,
     ) -> Option<HashMap<&'a str, Vec<String>>> {
@@ -886,8 +904,10 @@ impl<'a, 'b> Matcher<'a, 'b> {
         let script_path = self.script_path.as_ref()?;
         let mut choices_fn_values = HashMap::new();
         let mut envs = HashMap::new();
-        envs.insert("ARGC_OS".into(), get_os());
-        let outputs = run_param_fns(script_path, &fns, self.args, envs)?;
+        envs.insert("ARGC_OS".into(), self.runtime.os());
+        let outputs = self
+            .runtime
+            .exec_bash_functions(script_path, &fns, self.args, envs)?;
         for (i, output) in outputs.into_iter().enumerate() {
             let choices = output
                 .split('\n')
@@ -943,17 +963,18 @@ impl<'a, 'b> Matcher<'a, 'b> {
         output
     }
 
+    #[cfg(feature = "eval")]
     fn stringify_match_error(&self, err: &MatchError) -> (String, i32) {
         let mut exit = 0;
         let message = match err {
             MatchError::DisplayHelp => {
                 let cmd = self.last_cmd();
-                cmd.render_help(self.term_width)
+                cmd.render_help(self.wrap_width)
             }
             MatchError::DisplaySubcommandHelp(name) => {
                 let cmd = self.last_cmd();
                 let cmd = cmd.find_subcommand(name).unwrap();
-                cmd.render_help(self.term_width)
+                cmd.render_help(self.wrap_width)
             }
             MatchError::DisplayVersion => {
                 let cmd = self.last_cmd();
@@ -1043,6 +1064,7 @@ impl<'a, 'b> Matcher<'a, 'b> {
         (message, exit)
     }
 
+    #[cfg(feature = "compgen")]
     fn comp_flag_options(&self, combine: bool) -> Vec<CompItem> {
         let mut output = vec![];
         let level = self.cmds.len() - 1;
@@ -1088,9 +1110,6 @@ impl<'a, 'b> Matcher<'a, 'b> {
     }
 }
 
-/// (value, description, nospace, color)
-pub(crate) type CompItem = (String, String, bool, CompColor);
-
 #[derive(Debug)]
 struct BindEnvs<'a, 'x> {
     flag_options: Vec<BindEnvMap<'a, 'x>>,
@@ -1283,6 +1302,7 @@ fn add_param_choice_fn<'a>(choice_fns: &mut HashSet<&'a str>, param: &'a impl Pa
     }
 }
 
+#[cfg(feature = "compgen")]
 fn comp_subcommands_positional(
     cmd: &Command,
     values: &[Vec<&str>],
@@ -1307,6 +1327,7 @@ fn comp_subcommands_positional(
     output
 }
 
+#[cfg(feature = "compgen")]
 fn comp_subcomands(cmd: &Command, flag: bool) -> Vec<CompItem> {
     let mut output = vec![];
     let mut has_help_subcmd = false;
@@ -1347,6 +1368,7 @@ fn comp_subcomands(cmd: &Command, flag: bool) -> Vec<CompItem> {
     output
 }
 
+#[cfg(feature = "compgen")]
 fn comp_symbol(cmd: &Command, ch: char) -> Vec<CompItem> {
     if let Some((name, choices_fn)) = cmd.symbols.get(&ch) {
         match choices_fn {
@@ -1372,6 +1394,7 @@ fn comp_symbol(cmd: &Command, ch: char) -> Vec<CompItem> {
     }
 }
 
+#[cfg(feature = "compgen")]
 fn comp_flag_option(param: &FlagOptionParam, index: usize) -> Vec<CompItem> {
     let value_name = param
         .notations()
@@ -1381,10 +1404,12 @@ fn comp_flag_option(param: &FlagOptionParam, index: usize) -> Vec<CompItem> {
     comp_param(param.describe_oneline(), value_name, param.data())
 }
 
+#[cfg(feature = "compgen")]
 fn comp_positional(param: &PositionalParam) -> Vec<CompItem> {
     comp_param(param.describe_oneline(), param.notation(), param.data())
 }
 
+#[cfg(feature = "compgen")]
 fn comp_param(describe: &str, value_name: &str, data: &ParamData) -> Vec<CompItem> {
     let choices: Option<Either<Vec<String>, String>> =
         if let Some((choice_fn, _)) = data.choice_fn() {
diff --git a/src/param.rs b/src/param.rs
index a1ba8656..ac5b3aa9 100644
--- a/src/param.rs
+++ b/src/param.rs
@@ -212,6 +212,7 @@ impl FlagOptionParam {
         }
     }
 
+    #[cfg(feature = "export")]
     pub(crate) fn export(&self) -> FlagOptionValue {
         FlagOptionValue {
             id: self.id().to_string(),
@@ -481,6 +482,7 @@ impl FlagOptionParam {
     }
 }
 
+#[cfg(feature = "export")]
 #[derive(Debug, Serialize)]
 pub struct FlagOptionValue {
     pub id: String,
@@ -571,6 +573,7 @@ impl PositionalParam {
         }
     }
 
+    #[cfg(feature = "export")]
     pub(crate) fn export(&self) -> PositionalValue {
         PositionalValue {
             id: self.id().to_string(),
@@ -622,6 +625,7 @@ impl PositionalParam {
     }
 }
 
+#[cfg(feature = "export")]
 #[derive(Debug, Serialize)]
 pub struct PositionalValue {
     pub id: String,
@@ -700,6 +704,7 @@ impl EnvParam {
         }
     }
 
+    #[cfg(feature = "export")]
     pub(crate) fn export(&self) -> EnvValue {
         EnvValue {
             id: self.id().to_string(),
@@ -731,6 +736,7 @@ impl EnvParam {
     }
 }
 
+#[cfg(feature = "export")]
 #[derive(Debug, Serialize)]
 pub struct EnvValue {
     pub id: String,
diff --git a/src/runtime/mod.rs b/src/runtime/mod.rs
new file mode 100644
index 00000000..cbef9b99
--- /dev/null
+++ b/src/runtime/mod.rs
@@ -0,0 +1,90 @@
+#[cfg(feature = "native-runtime")]
+pub mod navite;
+
+use anyhow::Result;
+use std::collections::HashMap;
+
+pub trait Runtime
+where
+    Self: Copy + Clone,
+{
+    const INTERNAL_SYMBOL: &'static str = "___internal___";
+    fn os(&self) -> String;
+    fn shell_path(&self) -> Result<String>;
+    fn bash_path(&self) -> Option<String>;
+    fn exec_bash_functions(
+        &self,
+        script_file: &str,
+        functions: &[&str],
+        args: &[String],
+        envs: HashMap<String, String>,
+    ) -> Option<Vec<String>>;
+    fn current_exe(&self) -> Option<String>;
+    fn current_dir(&self) -> Option<String>;
+    fn env_vars(&self) -> HashMap<String, String>;
+    fn env_var(&self, name: &str) -> Option<String>;
+    fn which(&self, name: &str) -> Option<String>;
+    fn exist_path(&self, path: &str) -> bool;
+    fn parent_path(&self, path: &str) -> Option<String>;
+    fn join_path(&self, path: &str, parts: &[&str]) -> String;
+    fn chdir(&self, cwd: &str, cd: &str) -> Option<String>;
+    fn metadata(&self, path: &str) -> Option<(bool, bool, bool)>;
+    fn read_dir(&self, path: &str) -> Option<Vec<String>>;
+    fn read_to_string(&self, path: &str) -> Option<String>;
+
+    fn is_windows(&self) -> bool {
+        self.os() == "windows"
+    }
+
+    fn shell_args(&self, shell_path: &str) -> Vec<String> {
+        if let Some(name) = self.basename(shell_path).map(|v| v.to_lowercase()) {
+            match name.as_str() {
+                "bash" => vec!["--noprofile".to_string(), "--norc".to_string()],
+                _ => vec![],
+            }
+        } else {
+            vec![]
+        }
+    }
+
+    fn basename(&self, path: &str) -> Option<String> {
+        let parts: Vec<_> = path.split(['/', '\\']).collect();
+        let last_part = parts.last()?;
+        let name = match last_part.rsplit_once('.') {
+            Some((v, _)) => v.to_string(),
+            None => last_part.to_string(),
+        };
+        Some(name)
+    }
+
+    fn load_dotenv(&self, path: &str) -> Option<HashMap<String, String>> {
+        let contents = self.read_to_string(path)?;
+        let mut output = HashMap::new();
+        for line in contents.lines() {
+            if line.starts_with('#') || line.trim().is_empty() {
+                continue;
+            }
+            if let Some((key, value)) = line.split_once('=') {
+                let key = key.trim().to_string();
+                let value = value.trim().to_string();
+                output.insert(key, value);
+            }
+        }
+        Some(output)
+    }
+
+    fn path_env_with_current_exe(&self) -> String {
+        let mut path_env = self.env_var("PATH").unwrap_or_default();
+        if let Some(exe_dir) = self
+            .current_exe()
+            .and_then(|exe_path| self.parent_path(&exe_path))
+        {
+            if self.is_windows() {
+                path_env = format!("{};{}", exe_dir, path_env)
+            } else {
+                path_env = format!("{}:{}", exe_dir, path_env)
+            }
+        }
+        path_env
+    }
+}
diff --git a/src/runtime/navite.rs b/src/runtime/navite.rs
new file mode 100644
index 00000000..4afb5fd5
--- /dev/null
+++ b/src/runtime/navite.rs
@@ -0,0 +1,177 @@
+use super::Runtime;
+
+use anyhow::{anyhow, bail, Result};
+use std::{env, fs, path::Path, process, thread};
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct NativeRuntime;
+
+impl Runtime for NativeRuntime {
+    fn os(&self) -> String {
+        env::consts::OS.to_string()
+    }
+
+    fn shell_path(&self) -> Result<String> {
+        match self.env_var("ARGC_SHELL_PATH") {
+            Some(shell_path) => {
+                if !self.exist_path(&shell_path) {
+                    bail!("Invalid ARGC_SHELL_PATH, '{shell_path}' does not exist",);
+                }
+                Ok(shell_path)
+            }
+            None => self.bash_path().ok_or_else(|| anyhow!("Shell not found")),
+        }
+    }
+
+    #[cfg(windows)]
+    fn bash_path(&self) -> Option<String> {
+        let bash_path = "C:\\Program Files\\Git\\bin\\bash.exe";
+        if self.exist_path(bash_path) {
+            return Some(bash_path.into());
+        }
+        let git_path = self.which("git")?;
+        let git_parent_path = self.parent_path(&git_path)?;
+        let bash_path = self.join_path(self.parent_path(&git_parent_path)?, &["bin", "bash.exe"]);
+        if self.exist_path(&bash_path) {
+            return Some(bash_path);
+        }
+        let bash_path = self.join_path(&git_parent_path, &["bash.exe"]);
+        if self.exist_path(&bash_path) {
+            return Some(bash_path);
+        }
+        None
+    }
+
+    #[cfg(not(windows))]
+    fn bash_path(&self) -> Option<String> {
+        self.which("bash")
+    }
+
+    fn exec_bash_functions(
+        &self,
+        script_file: &str,
+        functions: &[&str],
+        args: &[String],
+        envs: std::collections::HashMap<String, String>,
+    ) -> Option<Vec<String>> {
+        let shell = self.shell_path().ok()?;
+        let shell_args = self.shell_args(&shell);
+        let path_env = self.path_env_with_current_exe();
+        let handles: Vec<_> = functions
+            .iter()
+            .map(|func| {
+                let script_file = script_file.to_string();
+                let args: Vec<String> = args.to_vec();
+                let path_env = path_env.clone();
+                let func = func.to_string();
+                let shell = shell.clone();
+                let shell_args = shell_args.clone();
+                let envs = envs.clone();
+                thread::spawn(move || {
+                    process::Command::new(shell)
+                        .args(shell_args)
+                        .arg(&script_file)
+                        .arg(Self::INTERNAL_SYMBOL)
+                        .arg(&func)
+                        .args(args)
+                        .envs(envs)
+                        .env("PATH", path_env)
+                        .output()
+                        .ok()
+                        .map(|out| String::from_utf8_lossy(&out.stdout).to_string())
+                        .unwrap_or_default()
+                })
+            })
+            .collect();
+        let result: Vec<String> = handles
+            .into_iter()
+            .map(|h| {
+                h.join()
+                    .ok()
+                    .map(|v| v.trim().to_string())
+                    .unwrap_or_default()
+            })
+            .collect();
+        Some(result)
+    }
+
+    fn current_exe(&self) -> Option<String> {
+        env::current_exe()
+            .ok()
+            .map(|path| path.to_string_lossy().into())
+    }
+
+    fn current_dir(&self) -> Option<String> {
+        env::current_dir()
+            .ok()
+            .map(|path| path.to_string_lossy().into())
+    }
+
+    fn env_vars(&self) -> std::collections::HashMap<String, String> {
+        env::vars().collect()
+    }
+
+    fn env_var(&self, name: &str) -> Option<String> {
+        env::var(name).ok()
+    }
+
+    fn which(&self, name: &str) -> Option<String> {
+        which::which(name)
+            .ok()
+            .map(|path| path.to_string_lossy().into())
+    }
+
+    fn exist_path(&self, path: &str) -> bool {
+        Path::new(path).exists()
+    }
+
+    fn parent_path(&self, path: &str) -> Option<String> {
+        Path::new(path)
+            .parent()
+            .map(|path| path.to_string_lossy().into())
+    }
+
+    fn join_path(&self, path: &str, parts: &[&str]) -> String {
+        let mut path = Path::new(path).to_path_buf();
+        for part in parts {
+            path = path.join(part);
+        }
+        path.to_string_lossy().into()
+    }
+
+    fn chdir(&self, cwd: &str, cd: &str) -> Option<String> {
+        let path = Path::new(cwd).join(cd).canonicalize().ok()?;
+        Some(path.to_string_lossy().into())
+    }
+
+    fn metadata(&self, path: &str) -> Option<(bool, bool, bool)> {
+        let mut meta = fs::symlink_metadata(path).ok()?;
+        let is_symlink = meta.is_symlink();
+        if is_symlink {
+            meta = fs::metadata(path).ok()?;
+        }
+        let is_dir = meta.is_dir();
+        let mut is_executable = false;
+        #[cfg(not(windows))]
+        if meta.is_file() {
+            use std::os::unix::fs::PermissionsExt;
+            is_executable = meta.permissions().mode() & 0o111 != 0;
+        }
+        Some((is_dir, is_symlink, is_executable))
+    }
+
+    fn read_dir(&self, path: &str) -> Option<Vec<String>> {
+        let dir = fs::read_dir(path).ok()?;
+        let mut paths = vec![];
+        for entry in dir {
+            let entry = entry.ok()?;
+            paths.push(entry.file_name().to_string_lossy().into());
+        }
+        Some(paths)
+    }
+
+    fn read_to_string(&self, path: &str) -> Option<String> {
+        let data = fs::read_to_string(path).ok()?;
+        Some(data)
+    }
+}
diff --git a/src/shell.rs b/src/shell.rs
new file mode 100644
index 00000000..6c2fd1cc
--- /dev/null
+++ b/src/shell.rs
@@ -0,0 +1,424 @@
+use std::str::FromStr;
+
+use anyhow::bail;
+
+use crate::{
+    utils::{is_quote_char, is_true_value, unbalance_quote},
+    Runtime,
+};
+
+#[cfg(feature = "compgen")]
+use crate::compgen::{CandidateValue, CompColor};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Shell {
+    Bash,
+    Elvish,
+    Fish,
+    Generic,
+    Nushell,
+    Powershell,
+    Xonsh,
+    Zsh,
+    Tcsh,
+}
+
+impl FromStr for Shell {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        match s {
+            "bash" => Ok(Self::Bash),
+            "elvish" => Ok(Self::Elvish),
+            "fish" => Ok(Self::Fish),
+            "generic" => Ok(Self::Generic),
+            "nushell" => Ok(Self::Nushell),
+            "powershell" => Ok(Self::Powershell),
+            "xonsh" => Ok(Self::Xonsh),
+            "zsh" => Ok(Self::Zsh),
+            "tcsh" => Ok(Self::Tcsh),
+            _ => bail!(
+                "The provided shell is either invalid or missing, must be one of {}",
+                Shell::list_names(),
+            ),
+        }
+    }
+}
+
+impl Shell {
+    pub fn list() -> [Shell; 8] {
+        [
+            Shell::Bash,
+            Shell::Elvish,
+            Shell::Fish,
+            Shell::Nushell,
+            Shell::Powershell,
+            Shell::Xonsh,
+            Shell::Zsh,
+            Shell::Tcsh,
+        ]
+    }
+
+    pub fn list_names() -> String {
+        Shell::list()
+            .iter()
+            .map(|v| v.name())
+            .collect::<Vec<&str>>()
+            .join(",")
+    }
+
+    pub fn name(&self) -> &str {
+        match self {
+            Shell::Bash => "bash",
+            Shell::Elvish => "elvish",
+            Shell::Fish => "fish",
+            Shell::Generic => "generic",
+            Shell::Nushell => "nushell",
+            Shell::Powershell => "powershell",
+            Shell::Xonsh => "xonsh",
+            Shell::Zsh => "zsh",
+            Shell::Tcsh => "tcsh",
+        }
+    }
+
+    pub fn is_generic(&self) -> bool {
+        *self == Shell::Generic
+    }
+
+    pub fn is_unix_only(&self) -> bool {
+        matches!(self, Shell::Bash | Shell::Fish | Shell::Zsh | Shell::Tcsh)
+    }
+}
+
+#[cfg(feature = "compgen")]
+impl Shell {
+    pub(crate) fn convert_candidates(
+        &self,
+        candidates: Vec<CandidateValue>,
+        prefix: &str,
+        filter: &str,
+        no_color: bool,
+    ) -> Vec<String> {
+        match self {
+            Shell::Bash => {
+                let prefix_unbalance = unbalance_quote(prefix);
+                let values: Vec<&str> = candidates.iter().map(|(v, _, _, _)| v.as_str()).collect();
+                let mut add_space_to_first_candidate = false;
+                if values.len() == 1 {
+                    let space = if candidates[0].2 { "" } else { " " };
+                    let mut value = format!("{prefix}{}", candidates[0].0);
+                    if prefix_unbalance.is_none() {
+                        value = self.escape(&value);
+                    }
+                    return vec![format!("{value}{space}")];
+                } else if let Some(common) = Self::common_prefix(&values) {
+                    if common != filter {
+                        if common != "--" {
+                            let mut value = format!("{prefix}{common}");
+                            if prefix_unbalance.is_none() {
+                                value = self.escape(&value);
+                            }
+                            return vec![value];
+                        }
+                    } else if !prefix.is_empty() && !common.starts_with(prefix) {
+                        add_space_to_first_candidate = true;
+                    }
+                }
+                candidates
+                    .into_iter()
+                    .enumerate()
+                    .map(|(i, (value, description, nospace, _comp_color))| {
+                        let mut new_value = if prefix_unbalance.is_none() {
+                            self.escape(&value)
+                        } else {
+                            value
+                        };
+                        if i == 0 && add_space_to_first_candidate {
+                            new_value = format!(" {}", new_value)
+                        };
+                        let description = self.comp_description(&description, "(", ")");
+                        if description.is_empty() {
+                            let space = if nospace { "" } else { " " };
+                            format!("{new_value}{space}")
+                        } else {
+                            format!("{new_value} {description}")
+                        }
+                    })
+                    .collect::<Vec<String>>()
+            }
+            Shell::Elvish | Shell::Powershell => candidates
+                .into_iter()
+                .map(|(value, description, nospace, comp_color)| {
+                    let new_value = self.combine_value(prefix, &value);
+                    let display = if value.is_empty() { " ".into() } else { value };
+                    let description = self.comp_description(&description, "", "");
+                    let space: &str = if nospace { "0" } else { "1" };
+                    let color = self.color(comp_color, no_color);
+                    format!("{new_value}\t{space}\t{display}\t{description}\t{color}")
+                })
+                .collect::<Vec<String>>(),
+            Shell::Fish => candidates
+                .into_iter()
+                .map(|(value, description, _nospace, _comp_color)| {
+                    let new_value = self.combine_value(prefix, &value);
+                    let description = self.comp_description(&description, "\t", "");
+                    format!("{new_value}{description}")
+                })
+                .collect::<Vec<String>>(),
+            Shell::Generic => candidates
+                .into_iter()
+                .map(|(value, description, nospace, comp_color)| {
+                    let comp_color = format!("\t/color:{}", comp_color.ser());
+                    let description = self.comp_description(&description, "\t", "");
+                    let space: &str = if nospace { "\0" } else { "" };
+                    format!("{value}{space}{comp_color}{description}")
+                })
+                .collect::<Vec<String>>(),
+            Shell::Nushell => candidates
+                .into_iter()
+                .map(|(value, description, nospace, _)| {
+                    let new_value = self.combine_value(prefix, &value);
+                    let space = if nospace { "" } else { " " };
+                    let description = self.comp_description(&description, "\t", "");
+                    format!("{new_value}{space}{description}")
+                })
+                .collect::<Vec<String>>(),
+            Shell::Xonsh => candidates
+                .into_iter()
+                .map(|(value, description, nospace, _)| {
+                    let mut new_value = format!("{prefix}{value}");
+                    if unbalance_quote(prefix).is_none() {
+                        let escaped_new_value = self.escape(&new_value);
+                        if escaped_new_value.ends_with("\\'")
+                            && !escaped_new_value.ends_with("\\\\'")
+                        {
+                            new_value = format!(
+                                "{}\\'",
+                                &escaped_new_value.as_str()[0..escaped_new_value.len() - 1]
+                            );
+                        } else {
+                            new_value = escaped_new_value
+                        }
+                    } else if new_value.ends_with('\\') && !new_value.ends_with("\\\\") {
+                        new_value.push('\\')
+                    }
+                    let display = if value.is_empty() { " ".into() } else { value };
+                    let description = self.comp_description(&description, "", "");
+                    let space: &str = if nospace { "0" } else { "1" };
+                    format!("{new_value}\t{space}\t{display}\t{description}")
+                })
+                .collect::<Vec<String>>(),
+            Shell::Zsh => candidates
+                .into_iter()
+                .map(|(value, description, nospace, comp_color)| {
+                    let new_value = if let Some((ch, i)) = unbalance_quote(prefix) {
+                        if i == 0 {
+                            format!("{}{value}", &prefix[1..])
+                        } else {
+                            format!(
+                                "{}{ch}{}{value}",
+                                self.escape(&prefix[0..i]),
+                                &prefix[i + 1..]
+                            )
+                        }
+                    } else {
+                        self.escape(&format!("{prefix}{value}"))
+                    };
+
+                    let new_value = new_value.replace(':', "\\:");
+                    let display = value.replace(':', "\\:");
+                    let description = self.comp_description(&description, ":", "");
+                    let color = self.color(comp_color, no_color);
+                    let space = if nospace { "" } else { " " };
+                    format!("{new_value}{space}\t{display}{description}\t{value}\t{color}")
+                })
+                .collect::<Vec<String>>(),
+            Shell::Tcsh => {
+                if candidates.len() == 1 {
+                    let new_value =
+                        Self::sanitize_tcsh_value(&self.combine_value(prefix, &candidates[0].0));
+                    return vec![new_value];
+                }
+                candidates
+                    .into_iter()
+                    .map(|(value, description, _, _)| {
+                        let new_value =
+                            Self::sanitize_tcsh_value(&self.combine_value(prefix, &value));
+                        let description = self.comp_description(&description, " (", ")");
+                        let description = description.replace(' ', "⠀");
+                        format!("{new_value}{description}")
+                    })
+                    .collect::<Vec<String>>()
+            }
+        }
+    }
+
+    pub(crate) fn need_description<T: Runtime>(&self, runtime: T) -> bool {
+        match runtime.env_var("ARGC_COMPGEN_DESCRIPTION") {
+            Some(v) => is_true_value(&v),
+            None => true,
+        }
+    }
+
+    pub(crate) fn escape(&self, value: &str) -> String {
+        match self {
+            Shell::Bash => Self::escape_chars(value, self.need_escape_chars(), "\\"),
+            Shell::Nushell | Shell::Powershell | Shell::Xonsh => {
+                if Self::contains_chars(value, self.need_escape_chars()) {
+                    format!("'{value}'")
+                } else {
+                    value.into()
+                }
+            }
+            Shell::Zsh => Self::escape_chars(value, self.need_escape_chars(), "\\\\"),
+            _ => value.into(),
+        }
+    }
+
+    pub(crate) fn color(&self, comp_color: CompColor, no_color: bool) -> String {
+        match self {
+            Shell::Elvish => {
+                if no_color {
+                    return "default".into();
+                }
+                comp_color.style()
+            }
+            Shell::Powershell | Shell::Zsh => {
+                if no_color {
+                    return "39".into();
+                }
+                comp_color.ansi_code()
+            }
+            _ => String::new(),
+        }
+    }
+
+    pub(crate) fn redirect_symbols(&self) -> Vec<&str> {
+        match self {
+            Shell::Nushell => vec![],
+            _ => vec!["<", ">"],
+        }
+    }
+
+    pub(crate) fn is_windows_mode<T: Runtime>(&self, runtime: T) -> bool {
+        if runtime.is_windows() {
+            !self.is_unix_only()
+        } else {
+            false
+        }
+    }
+
+    pub(crate) fn need_escape_chars(&self) -> &str {
+        match self {
+            Shell::Bash => r#"()<>"'` !#$&;\|"#,
+            Shell::Nushell => r#"()[]{}"'` #$;|"#,
+            Shell::Powershell => r#"()<>[]{}"'` #$&;@|"#,
+            Shell::Xonsh => r#"()<>[]{}!"'` #&;|"#,
+            Shell::Zsh => r#"()<>[]"'` !#$&*;?\|"#,
+            _ => "",
+        }
+    }
+
+    pub(crate) fn need_break_chars<T: Runtime>(&self, runtime: T, last_arg: &str) -> Vec<char> {
+        if last_arg.starts_with(is_quote_char) {
+            return vec![];
+        }
+        match self {
+            Shell::Bash => match runtime.env_var("COMP_WORDBREAKS") {
+                Some(v) => [':', '=', '@']
+                    .iter()
+                    .filter(|c| v.contains(**c))
+                    .copied()
+                    .collect(),
+                None => [':', '=', '@'].to_vec(),
+            },
+            Shell::Powershell => vec![','],
+            _ => vec![],
+        }
+    }
+
+    pub(crate) fn need_expand_tilde<T: Runtime>(&self, runtime: T) -> bool {
+        self.is_windows_mode(runtime) && self == &Self::Powershell
+    }
+
+    fn combine_value(&self, prefix: &str, value: &str) -> String {
+        let mut new_value = format!("{prefix}{value}");
+        if unbalance_quote(prefix).is_none() {
+            new_value = self.escape(&new_value);
+        }
+        new_value
+    }
+
+    fn comp_description(&self, description: &str, prefix: &str, suffix: &str) -> String {
+        if description.is_empty() {
+            String::new()
+        } else {
+            format!(
+                "{prefix}{}{suffix}",
+                Self::truncate_description(description)
+            )
+        }
+    }
+
+    fn truncate_description(description: &str) -> String {
+        let max_width = 80;
+        let mut description = description.trim().replace('\t', "");
+        if description.starts_with('(') && description.ends_with(')') {
+            description = description
+                .trim_start_matches('(')
+                .trim_end_matches(')')
+                .to_string();
+        }
+        if description.chars().count() < max_width {
+            description
+        } else {
+            let truncated: String = description.chars().take(max_width).collect();
+            format!("{}...", truncated)
+        }
+    }
+
+    fn common_prefix(strings: &[&str]) -> Option<String> {
+        if strings.is_empty() {
+            return None;
+        }
+        let mut prefix = String::new();
+        for (i, c) in strings[0].chars().enumerate() {
+            for s in &strings[1..] {
+                if i >= s.len() || s.chars().nth(i) != Some(c) {
+                    if prefix.is_empty() {
+                        return None;
+                    }
+                    return Some(prefix);
+                }
+            }
+            prefix.push(c);
+        }
+        if prefix.is_empty() {
+            return None;
+        }
+        Some(prefix)
+    }
+
+    fn escape_chars(value: &str, need_escape: &str, for_escape: &str) -> String {
+        let chars: Vec<char> = need_escape.chars().collect();
+        value
+            .chars()
+            .map(|c| {
+                if chars.contains(&c) {
+                    format!("{for_escape}{c}")
+                } else {
+                    c.to_string()
+                }
+            })
+            .collect()
+    }
+
+    fn contains_chars(value: &str, chars: &str) -> bool {
+        let value_chars: Vec<char> = value.chars().collect();
+        chars.chars().any(|v| value_chars.contains(&v))
+    }
+
+    fn sanitize_tcsh_value(value: &str) -> String {
+        value.replace(' ', "⠀")
+    }
+}
diff --git a/src/utils.rs b/src/utils.rs
index b38d0b96..7627a2f4 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,11 +1,4 @@
 use convert_case::{Boundary, Converter, Pattern};
-use std::{
-    collections::HashMap,
-    env, fs,
-    path::{Path, PathBuf},
-    process, thread,
-};
-use which::which;
 
 pub const INTERNAL_SYMBOL: &str = "___internal___";
 pub const VARIABLE_PREFIX: &str = "argc_";
@@ -14,6 +7,9 @@ pub const AFTER_HOOK: &str = "_argc_after";
 pub const ROOT_NAME: &str = "prog";
 pub const MAIN_NAME: &str = "main";
 
+#[cfg(feature = "compgen")]
+pub const ARGC_COMPLETION_SCRIPT_PATH: &str = "___argc_completion_script_path___";
+
 pub(crate) const META_VERSION: &str = "version";
 pub(crate) const META_AUTHOR: &str = "author";
 pub(crate) const META_DOTENV: &str = "dotenv";
@@ -26,7 +22,8 @@ pub(crate) const META_REQUIRE_TOOLS: &str = "require-tools";
 
 pub(crate) const MAX_ARGS: usize = 32767;
 
-pub(crate) const ARGC_REQUIRE_TOOLS: &str = r#"_argc_require_tools() {
+#[cfg(any(feature = "build", feature = "eval-bash"))]
+pub const ARGC_REQUIRE_TOOLS: &str = r#"_argc_require_tools() {
     local tool missing_tools=()
     for tool in "$@"; do
         if ! command -v "$tool" >/dev/null 2>&1; then
@@ -39,6 +36,12 @@ pub(crate) const ARGC_REQUIRE_TOOLS: &str = r#"_argc_require_tools() {
     fi
 }"#;
 
+#[cfg(any(feature = "build", feature = "eval-bash"))]
+pub fn expand_dotenv(value: &str) -> String {
+    let value = escape_shell_words(value);
+    format!("[ -f {value} ] && set -o allexport && . {value} && set +o allexport")
+}
+
 pub fn to_cobol_case(value: &str) -> String {
     Converter::new()
         .set_pattern(Pattern::Uppercase)
@@ -55,113 +58,23 @@ pub fn is_quote_char(c: char) -> bool {
     c == '\'' || c == '"'
 }
 
-pub fn get_shell_path() -> anyhow::Result<PathBuf> {
-    match env::var("ARGC_SHELL_PATH") {
-        Ok(v) => {
-            let shell_path = Path::new(&v).to_path_buf();
-            if !shell_path.exists() {
-                anyhow::bail!(
-                    "Invalid ARGC_SHELL_PATH, '{}' does not exist",
-                    shell_path.display()
-                );
+pub fn unbalance_quote(value: &str) -> Option<(char, usize)> {
+    let mut balance = None;
+    for (i, c) in value.chars().enumerate() {
+        match balance {
+            Some((c_, _)) => {
+                if c == c_ {
+                    balance = None
+                }
+            }
+            None => {
+                if is_quote_char(c) {
+                    balance = Some((c, i))
+                }
             }
-            Ok(shell_path)
-        }
-        Err(_) => get_bash_path().ok_or_else(|| anyhow::anyhow!("Shell not found")),
-    }
-}
-
-pub fn get_shell_args(shell_path: &Path) -> Vec<String> {
-    if let Some(name) = shell_path
-        .file_stem()
-        .map(|v| v.to_string_lossy().to_lowercase())
-    {
-        match name.as_str() {
-            "bash" => vec!["--noprofile".to_string(), "--norc".to_string()],
-            _ => vec![],
         }
-    } else {
-        vec![]
     }
-}
-
-pub fn get_os() -> String {
-    env::consts::OS.to_string()
-}
-
-#[cfg(windows)]
-pub fn get_bash_path() -> Option<PathBuf> {
-    let bash_path = PathBuf::from("C:\\Program Files\\Git\\bin\\bash.exe");
-    if bash_path.exists() {
-        return Some(bash_path);
-    }
-    let git = which("git").ok()?;
-    let parent = git.parent()?;
-    let bash_path = parent.parent()?.join("bin").join("bash.exe");
-    if bash_path.exists() {
-        return Some(bash_path);
-    }
-    let bash_path = parent.join("bash.exe");
-    if bash_path.exists() {
-        return Some(bash_path);
-    }
-    None
-}
-
-#[cfg(not(windows))]
-pub fn get_bash_path() -> Option<PathBuf> {
-    which("bash").ok()
-}
-
-pub fn run_param_fns(
-    script_file: &str,
-    param_fns: &[&str],
-    args: &[String],
-    envs: HashMap<String, String>,
-) -> Option<Vec<String>> {
-    let shell = get_shell_path().ok()?;
-    let shell_extra_args = get_shell_args(&shell);
-    let path_env = path_env_with_exe();
-    let handles: Vec<_> = param_fns
-        .iter()
-        .map(|param_fn| {
-            let script_file = script_file.to_string();
-            let args: Vec<String> = args.to_vec();
-            let path_env = path_env.clone();
-            let param_fn = param_fn.to_string();
-            let shell = shell.clone();
-            let shell_extra_args = shell_extra_args.clone();
-            let envs = envs.clone();
-            thread::spawn(move || {
-                process::Command::new(shell)
-                    .args(shell_extra_args)
-                    .arg(&script_file)
-                    .arg(INTERNAL_SYMBOL)
-                    .arg(&param_fn)
-                    .args(args)
-                    .envs(envs)
-                    .env("PATH", path_env)
-                    .output()
-                    .ok()
-                    .map(|out| String::from_utf8_lossy(&out.stdout).to_string())
-                    .unwrap_or_default()
-            })
-        })
-        .collect();
-    let result: Vec<String> = handles
-        .into_iter()
-        .map(|h| {
-            h.join()
-                .ok()
-                .map(|v| v.trim().to_string())
-                .unwrap_or_default()
-        })
-        .collect();
-    Some(result)
-}
-
-pub fn termwidth() -> Option<usize> {
-    env::var("TERM_WIDTH").ok()?.parse().ok()
+    balance
 }
 
 pub fn is_windows_path(value: &str) -> bool {
@@ -175,32 +88,6 @@ pub fn is_windows_path(value: &str) -> bool {
     })
 }
 
-pub fn get_current_dir() -> Option<String> {
-    env::current_dir()
-        .ok()
-        .map(|v| v.to_string_lossy().to_string())
-}
-
-pub fn path_env_with_exe() -> String {
-    let mut path_env = std::env::var("PATH").ok().unwrap_or_default();
-    if let Some(exe_dir) = std::env::current_exe()
-        .ok()
-        .and_then(|v| v.parent().map(|v| v.to_path_buf()))
-    {
-        if cfg!(windows) {
-            path_env = format!("{};{}", exe_dir.display(), path_env)
-        } else {
-            path_env = format!("{}:{}", exe_dir.display(), path_env)
-        }
-    }
-    path_env
-}
-
-pub fn expand_dotenv(value: &str) -> String {
-    let value = escape_shell_words(value);
-    format!("[ -f {value} ] && set -o allexport && . {value} && set +o allexport")
-}
-
 pub fn is_special_var_char(c: char) -> bool {
     matches!(c, '-' | '.' | ':' | '@')
 }
@@ -213,26 +100,6 @@ pub fn argc_var_name(id: &str) -> String {
     format!("{VARIABLE_PREFIX}{}", sanitize_var_name(id))
 }
 
-pub fn all_envs() -> HashMap<String, String> {
-    env::vars().collect()
-}
-
-pub fn load_dotenv(path: &str) -> Option<HashMap<String, String>> {
-    let contents = fs::read_to_string(path).ok()?;
-    let mut output = HashMap::new();
-    for line in contents.lines() {
-        if line.starts_with('#') || line.trim().is_empty() {
-            continue;
-        }
-        if let Some((key, value)) = line.split_once('=') {
-            let key = key.trim().to_string();
-            let value = value.trim().to_string();
-            output.insert(key, value);
-        }
-    }
-    Some(output)
-}
-
 pub fn is_true_value(value: &str) -> bool {
     matches!(value, "true" | "1")
 }
diff --git a/tests/fixtures.rs b/tests/fixtures.rs
index d498f104..129e8257 100644
--- a/tests/fixtures.rs
+++ b/tests/fixtures.rs
@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
+use argc::Runtime;
 use assert_cmd::cargo::cargo_bin;
 use assert_fs::fixture::{ChildPath, TempDir};
 use assert_fs::prelude::*;
@@ -96,7 +97,7 @@ pub fn build_script(script_dir: &TempDir, source: &str) -> PathBuf {
     echo "$argc__fn" "$@"
 }"#,
     );
-    let mut output = argc::build(&patched_source, "prog").unwrap();
+    let mut output = argc::build(&patched_source, "prog", None).unwrap();
     if !has_fn {
         output.push_str("\n( set -o posix ; set ) | grep ^argc_");
     }
@@ -113,7 +114,7 @@ pub fn run_script<T: AsRef<Path>>(
 ) -> String {
     let path_env_var = get_path_env_var();
     let envs: HashMap<&str, &str> = envs.iter().cloned().collect();
-    let shell_path = argc::utils::get_shell_path().unwrap();
+    let shell_path = argc::NativeRuntime.shell_path().unwrap();
     let output = std::process::Command::new(shell_path)
         .arg(script_path.as_ref())
         .args(args)
diff --git a/tests/macros.rs b/tests/macros.rs
index 891d2b94..27bb9cf2 100644
--- a/tests/macros.rs
+++ b/tests/macros.rs
@@ -20,7 +20,7 @@ macro_rules! fail {
         $err:expr
     ) => {
         let args: Vec<String> = $args.iter().map(|v| v.to_string()).collect();
-        let err = argc::eval($source, &args, None, None).unwrap_err();
+        let err = argc::eval(argc::NativeRuntime, $source, &args, None, None).unwrap_err();
         assert_eq!(err.to_string().as_str(), $err);
     };
 }
@@ -40,8 +40,8 @@ macro_rules! snapshot {
 		$width:expr
     ) => {
         let args: Vec<String> = $args.iter().map(|v| v.to_string()).collect();
-        let values = argc::eval($source, &args, $path, $width).unwrap();
-        let shell_code = argc::ArgcValue::to_shell(&values);
+        let values = argc::eval(argc::NativeRuntime, $source, &args, $path, $width).unwrap();
+        let shell_code = argc::ArgcValue::to_bash(&values);
         let build_script_dir = $crate::fixtures::tmpdir();
         let build_script_path = $crate::fixtures::build_script(&build_script_dir, $source);
         let build_output = $crate::fixtures::run_script(&build_script_path, &args[1..], &[]);
@@ -77,9 +77,15 @@ macro_rules! snapshot_multi {
 
         for args in $matrix.iter() {
             let args: Vec<String> = args.iter().map(|v| v.to_string()).collect();
-            let values =
-                argc::eval(&script_content, &args, Some(script_path.as_str()), None).unwrap();
-            let shell_code = argc::ArgcValue::to_shell(&values);
+            let values = argc::eval(
+                argc::NativeRuntime,
+                &script_content,
+                &args,
+                Some(script_path.as_str()),
+                None,
+            )
+            .unwrap();
+            let shell_code = argc::ArgcValue::to_bash(&values);
             let build_output = $crate::fixtures::run_script(&build_script_path, &args[1..], &[]);
             let args = args.join(" ");
             let piece = format!(
@@ -113,7 +119,14 @@ macro_rules! snapshot_compgen {
             $crate::fixtures::create_argc_script($source, "compgen.sh");
         for args in $matrix.iter() {
             let args: Vec<String> = args.iter().map(|v| v.to_string()).collect();
-            let words = match argc::compgen($shell, &script_path, &script_content, &args, false) {
+            let words = match argc::compgen(
+                argc::NativeRuntime,
+                $shell,
+                &script_path,
+                &script_content,
+                &args,
+                false,
+            ) {
                 Ok(stdout) => stdout,
                 Err(stderr) => stderr.to_string(),
             };
@@ -149,7 +162,14 @@ macro_rules! snapshot_compgen_shells {
             $crate::fixtures::create_argc_script($source, "compgen.sh");
         let args: Vec<String> = $args.iter().map(|v| v.to_string()).collect();
         for shell in argc::Shell::list() {
-            let words = match argc::compgen(shell, &script_path, &script_content, &args, false) {
+            let words = match argc::compgen(
+                argc::NativeRuntime,
+                shell,
+                &script_path,
+                &script_content,
+                &args,
+                false,
+            ) {
                 Ok(stdout) => stdout,
                 Err(stderr) => stderr.to_string(),
             };
diff --git a/tests/snapshots/integration__compgen__filedir__cd.snap b/tests/snapshots/integration__compgen__filedir__cd.snap
index a8561d49..47bb7b03 100644
--- a/tests/snapshots/integration__compgen__filedir__cd.snap
+++ b/tests/snapshots/integration__compgen__filedir__cd.snap
@@ -14,6 +14,8 @@ mangen.rs	1	mangen.rs		default
 matcher.rs	1	matcher.rs		default
 param.rs	1	param.rs		default
 parser.rs	1	parser.rs		default
+runtime/	0	runtime/		blue bold
+shell.rs	1	shell.rs		default
 utils.rs	1	utils.rs		default
 
 ************ COMPGEN `prog --oa=` ************
@@ -28,6 +30,8 @@ utils.rs	1	utils.rs		default
 --oa=matcher.rs	1	matcher.rs		default
 --oa=param.rs	1	param.rs		default
 --oa=parser.rs	1	parser.rs		default
+--oa=runtime/	0	runtime/		blue bold
+--oa=shell.rs	1	shell.rs		default
 --oa=utils.rs	1	utils.rs		default
 
 ************ COMPGEN `prog --ob ` ************
@@ -42,6 +46,8 @@ mangen.rs:	0	mangen.rs:		default
 matcher.rs:	0	matcher.rs:		default
 param.rs:	0	param.rs:		default
 parser.rs:	0	parser.rs:		default
+runtime/	0	runtime/		blue bold
+shell.rs:	0	shell.rs:		default
 utils.rs:	0	utils.rs:		default
 
 ************ COMPGEN `prog foo=` ************
@@ -56,4 +62,6 @@ foo=mangen.rs	1	mangen.rs		default
 foo=matcher.rs	1	matcher.rs		default
 foo=param.rs	1	param.rs		default
 foo=parser.rs	1	parser.rs		default
+foo=runtime/	0	runtime/		blue bold
+foo=shell.rs	1	shell.rs		default
 foo=utils.rs	1	utils.rs		default
diff --git a/tests/snapshots/integration__compgen__filedir__value_name.snap b/tests/snapshots/integration__compgen__filedir__value_name.snap
index 252b53ec..d3755e44 100644
--- a/tests/snapshots/integration__compgen__filedir__value_name.snap
+++ b/tests/snapshots/integration__compgen__filedir__value_name.snap
@@ -14,6 +14,8 @@ src/mangen.rs	1	mangen.rs		default
 src/matcher.rs	1	matcher.rs		default
 src/param.rs	1	param.rs		default
 src/parser.rs	1	parser.rs		default
+src/runtime/	0	runtime/		blue bold
+src/shell.rs	1	shell.rs		default
 src/utils.rs	1	utils.rs		default
 
 ************ COMPGEN `prog --oa src/p` ************
@@ -32,6 +34,8 @@ src/parser.rs	1	parser.rs		default
 ./src/matcher.rs	1	matcher.rs		default
 ./src/param.rs	1	param.rs		default
 ./src/parser.rs	1	parser.rs		default
+./src/runtime/	0	runtime/		blue bold
+./src/shell.rs	1	shell.rs		default
 ./src/utils.rs	1	utils.rs		default
 
 ************ COMPGEN `prog --oa C` ************
@@ -49,3 +53,4 @@ src/completions/argc.zsh	1	argc.zsh		default
 src/bin/	0	bin/		blue bold
 src/command/	0	command/		blue bold
 src/completions/	0	completions/		blue bold
+src/runtime/	0	runtime/		blue bold

From 781cf06073a18202f52a31221c2f82006c925c9d Mon Sep 17 00:00:00 2001
From: sigoden <sigoden@gmail.com>
Date: Sat, 27 Apr 2024 07:58:21 +0800
Subject: [PATCH 2/3] fix windows test

---
 src/runtime/navite.rs                               | 13 +++++++------
 .../integration__compgen__filedir__cd_win.snap      |  8 ++++++++
 ...tegration__compgen__filedir__value_name_win.snap |  5 +++++
 3 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/src/runtime/navite.rs b/src/runtime/navite.rs
index 4afb5fd5..bef557df 100644
--- a/src/runtime/navite.rs
+++ b/src/runtime/navite.rs
@@ -31,7 +31,7 @@ impl Runtime for NativeRuntime {
         }
         let git_path = self.which("git")?;
         let git_parent_path = self.parent_path(&git_path)?;
-        let bash_path = self.join_path(self.parent_path(&git_parent_path)?, &["bin", "bash.exe"]);
+        let bash_path = self.join_path(&self.parent_path(&git_parent_path)?, &["bin", "bash.exe"]);
         if self.exist_path(&bash_path) {
             return Some(bash_path);
         }
@@ -151,12 +151,13 @@ impl Runtime for NativeRuntime {
             meta = fs::metadata(path).ok()?;
         }
         let is_dir = meta.is_dir();
-        let mut is_executable = false;
-        #[cfg(not(windows))]
-        if meta.is_file() {
+        #[cfg(target_family = "unix")]
+        let is_executable = {
             use std::os::unix::fs::PermissionsExt;
-            is_executable = meta.permissions().mode() & 0o111 != 0;
-        }
+            meta.permissions().mode() & 0o111 != 0
+        };
+        #[cfg(not(target_family = "unix"))]
+        let is_executable = false;
         Some((is_dir, is_symlink, is_executable))
     }
 
diff --git a/tests/snapshots/integration__compgen__filedir__cd_win.snap b/tests/snapshots/integration__compgen__filedir__cd_win.snap
index d5c6d282..9a308bcf 100644
--- a/tests/snapshots/integration__compgen__filedir__cd_win.snap
+++ b/tests/snapshots/integration__compgen__filedir__cd_win.snap
@@ -14,6 +14,8 @@ expression: data
 .\matcher.rs	1	.\matcher.rs		39
 .\param.rs	1	.\param.rs		39
 .\parser.rs	1	.\parser.rs		39
+.\runtime\	0	.\runtime\		1;34
+.\shell.rs	1	.\shell.rs		39
 .\utils.rs	1	.\utils.rs		39
 
 ************ COMPGEN `prog --ob ` ************
@@ -28,6 +30,8 @@ expression: data
 .\matcher.rs:	0	.\matcher.rs:		39
 .\param.rs:	0	.\param.rs:		39
 .\parser.rs:	0	.\parser.rs:		39
+.\runtime\	0	.\runtime\		1;34
+.\shell.rs:	0	.\shell.rs:		39
 .\utils.rs:	0	.\utils.rs:		39
 
 ************ COMPGEN `prog --oa=` ************
@@ -42,6 +46,8 @@ expression: data
 --oa=.\matcher.rs	1	.\matcher.rs		39
 --oa=.\param.rs	1	.\param.rs		39
 --oa=.\parser.rs	1	.\parser.rs		39
+--oa=.\runtime\	0	.\runtime\		1;34
+--oa=.\shell.rs	1	.\shell.rs		39
 --oa=.\utils.rs	1	.\utils.rs		39
 
 ************ COMPGEN `prog foo=` ************
@@ -56,4 +62,6 @@ foo=.\mangen.rs	1	.\mangen.rs		39
 foo=.\matcher.rs	1	.\matcher.rs		39
 foo=.\param.rs	1	.\param.rs		39
 foo=.\parser.rs	1	.\parser.rs		39
+foo=.\runtime\	0	.\runtime\		1;34
+foo=.\shell.rs	1	.\shell.rs		39
 foo=.\utils.rs	1	.\utils.rs		39
diff --git a/tests/snapshots/integration__compgen__filedir__value_name_win.snap b/tests/snapshots/integration__compgen__filedir__value_name_win.snap
index 2ac18918..71aa6d00 100644
--- a/tests/snapshots/integration__compgen__filedir__value_name_win.snap
+++ b/tests/snapshots/integration__compgen__filedir__value_name_win.snap
@@ -14,6 +14,8 @@ src\mangen.rs	1	mangen.rs		39
 src\matcher.rs	1	matcher.rs		39
 src\param.rs	1	param.rs		39
 src\parser.rs	1	parser.rs		39
+src\runtime\	0	runtime\		1;34
+src\shell.rs	1	shell.rs		39
 src\utils.rs	1	utils.rs		39
 
 ************ COMPGEN `prog --oa src\p` ************
@@ -32,6 +34,8 @@ src\parser.rs	1	parser.rs		39
 .\src\matcher.rs	1	matcher.rs		39
 .\src\param.rs	1	param.rs		39
 .\src\parser.rs	1	parser.rs		39
+.\src\runtime\	0	runtime\		1;34
+.\src\shell.rs	1	shell.rs		39
 .\src\utils.rs	1	utils.rs		39
 
 ************ COMPGEN `prog --oa C` ************
@@ -49,3 +53,4 @@ src\completions\ar	0	src\completions\ar		39
 src\bin\	0	bin\		1;34
 src\command\	0	command\		1;34
 src\completions\	0	completions\		1;34
+src\runtime\	0	runtime\		1;34

From ec3f856a81e55d0c44152257dbbad43cfd0d6fc7 Mon Sep 17 00:00:00 2001
From: sigoden <sigoden@gmail.com>
Date: Sat, 27 Apr 2024 02:19:46 +0000
Subject: [PATCH 3/3] add features for Runtime

---
 src/lib.rs   | 1 +
 src/shell.rs | 8 ++++----
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index abf5abf5..9ec902f1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -34,6 +34,7 @@ pub use param::{ChoiceValue, DefaultValue};
 pub use param::{EnvValue, FlagOptionValue, PositionalValue};
 #[cfg(feature = "native-runtime")]
 pub use runtime::navite::NativeRuntime;
+#[cfg(any(feature = "eval", feature = "compgen"))]
 pub use runtime::Runtime;
 #[cfg(any(feature = "compgen", feature = "completions"))]
 pub use shell::Shell;
diff --git a/src/shell.rs b/src/shell.rs
index 6c2fd1cc..3b1cf1ad 100644
--- a/src/shell.rs
+++ b/src/shell.rs
@@ -2,14 +2,14 @@ use std::str::FromStr;
 
 use anyhow::bail;
 
+use crate::utils::{is_quote_char, is_true_value, unbalance_quote};
+
+#[cfg(feature = "compgen")]
 use crate::{
-    utils::{is_quote_char, is_true_value, unbalance_quote},
+    compgen::{CandidateValue, CompColor},
     Runtime,
 };
 
-#[cfg(feature = "compgen")]
-use crate::compgen::{CandidateValue, CompColor};
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Shell {
     Bash,