@tishlang/tish 1.3.8 → 1.5.0

package/crates/tish/src/main.rs

@@ -1,80 +1,59 @@
 //! Tish CLI - run, REPL, build to native or other targets.
 
+mod cli_help;
 mod repl_completion;
 
 use std::cell::RefCell;
+use std::collections::HashSet;
 use std::fs;
 use std::io::{self, IsTerminal, Read, Write};
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 
-use clap::{Parser, Subcommand};
+use clap::FromArgMatches;
 use rustyline::{Behavior, ColorMode, CompletionType, Config, Editor};
 
-#[derive(Parser)]
-#[command(name = "tish")]
-#[command(about = "Tish - minimal TS/JS-compatible language")]
-#[command(version = env!("CARGO_PKG_VERSION"))]
-#[command(after_help = "To disable optimizations: TISH_NO_OPTIMIZE=1")]
-pub(crate) struct Cli {
-    #[command(subcommand)]
-    command: Option<Commands>,
-}
-
-#[derive(Parser)]
-struct RunArgs {
-    /// Path to a `.tish` file, or `-` to read the program from stdin (like `node -`).
-    #[arg(required = true, allow_hyphen_values = true)]
-    file: String,
-    #[arg(long, default_value = "vm")]
-    backend: String,
-    /// Enable capabilities (http, fs, process, regex, ws). Must match how tish was built.
-    /// E.g. cargo run -p tishlang--features http,fs -- run script.tish --feature http,fs
-    #[arg(long = "feature", action = clap::ArgAction::Append)]
-    features: Vec<String>,
-    /// Disable AST and bytecode optimizations (for debugging)
-    #[arg(long)]
-    no_optimize: bool,
-}
+use cli_help::{Cli, Commands};
 
-#[derive(Parser)]
-struct ReplArgs {
-    #[arg(long, default_value = "vm")]
-    backend: String,
-    #[arg(long)]
-    no_optimize: bool,
+/// Normalize `--feature` / `--feature http,fs` / `--feature full` for VM runs and native builds.
+fn normalize_capability_flags(features: &[String]) -> HashSet<String> {
+    let mut out = HashSet::new();
+    for s in features {
+        for part in s.split(',').map(str::trim).filter(|p| !p.is_empty()) {
+            if part == "full" {
+                for name in ["http", "fs", "process", "regex", "ws"] {
+                    out.insert(name.to_string());
+                }
+            } else {
+                out.insert(part.to_string());
+            }
+        }
+    }
+    out
 }
 
-#[derive(Parser)]
-struct BuildArgs {
-    #[arg(short, long, default_value = "tish_out")]
-    output: String,
-    #[arg(long, default_value = "native")]
-    target: String,
-    #[arg(long, default_value = "rust")]
-    native_backend: String,
-    #[arg(long = "feature", action = clap::ArgAction::Append)]
-    features: Vec<String>,
-    #[arg(long)]
-    no_optimize: bool,
-    #[arg(required = true)]
-    file: String,
+/// VM capabilities for `run` / `repl` / stdin with the bytecode VM.
+///
+/// If the user passes no `--feature`, enable **everything linked into this `tish` binary**
+/// (so `cargo run --bin tish --features full -- script.tish` does not need `--feature full`).
+/// If they pass `--feature …`, use **only** that set (e.g. restrict a full build to `http` only).
+fn vm_capabilities_for_cli_run(cli_features: &[String]) -> HashSet<String> {
+    if cli_features.is_empty() {
+        tishlang_vm::all_compiled_capabilities()
+    } else {
+        normalize_capability_flags(cli_features)
+    }
 }
 
-#[derive(Subcommand)]
-pub(crate) enum Commands {
-    /// Run a Tish file (interpret)
-    Run(RunArgs),
-    /// Interactive REPL
-    Repl(ReplArgs),
-    /// Build native binary, wasm, wasi, or JavaScript output
-    Build(BuildArgs),
-    /// Parse and dump AST
-    #[command(name = "dump-ast")]
-    DumpAst {
-        #[arg(required = true)]
-        file: String,
-    },
+/// `--feature` list for `tish build --target native`: same default as `tish run` (all linked-in caps).
+fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
+    if cli_features.is_empty() {
+        let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities().into_iter().collect();
+        v.sort();
+        v
+    } else {
+        cli_features.to_vec()
+    }
 }
 
 /// `tish script.tish` → insert `run` so it matches `tish run script.tish` (npx / npm UX).
@@ -107,11 +86,17 @@ fn main() {
         return;
     }
 
+    if cli_help::argv_requests_help(&argv) {
+        cli_help::print_banner_with_help(&argv);
+        std::process::exit(0);
+    }
+
     let argv = argv_with_implicit_run(argv);
-    let cli = Cli::parse_from(argv);
+    let matches = cli_help::build_command().get_matches_from(&argv);
+    let cli = Cli::from_arg_matches(&matches).unwrap_or_else(|e| e.exit());
     let result = match cli.command {
         Some(Commands::Run(a)) => run_file(&a.file, &a.backend, &a.features, a.no_optimize || no_opt_env),
-        Some(Commands::Repl(a)) => run_repl(&a.backend, a.no_optimize || no_opt_env),
+        Some(Commands::Repl(a)) => run_repl(&a.backend, a.no_optimize || no_opt_env, &a.features),
         Some(Commands::Build(a)) => build_file(
             &a.file,
             &a.output,
@@ -123,7 +108,7 @@ fn main() {
         Some(Commands::DumpAst { file }) => dump_ast(&file),
         None => {
             if io::stdin().is_terminal() {
-                run_repl("vm", no_opt_env)
+                run_repl("vm", no_opt_env, &[])
             } else {
                 // `echo '...' | tish` — run script from stdin (Bun-style)
                 run_stdin_pipe("vm", &[], no_opt_env, false)
@@ -162,7 +147,7 @@ fn run_stdin_pipe(
 fn run_stdin_source(
     source: &str,
     backend: &str,
-    _features: &[String],
+    features: &[String],
     no_optimize: bool,
 ) -> Result<(), String> {
     let cwd = std::env::current_dir().map_err(|e| e.to_string())?;
@@ -174,7 +159,7 @@ fn run_stdin_source(
     } else {
         tishlang_opt::optimize(&prog)
     };
-    run_program(&program, backend, no_optimize)
+    run_program(&program, backend, no_optimize, features)
 }
 
 fn run_file(path: &str, backend: &str, features: &[String], no_optimize: bool) -> Result<(), String> {
@@ -211,10 +196,15 @@ fn run_file(path: &str, backend: &str, features: &[String], no_optimize: bool) -
         }
     };
 
-    run_program(&program, backend, no_optimize)
+    run_program(&program, backend, no_optimize, features)
 }
 
-fn run_program(program: &tishlang_ast::Program, backend: &str, no_optimize: bool) -> Result<(), String> {
+fn run_program(
+    program: &tishlang_ast::Program,
+    backend: &str,
+    no_optimize: bool,
+    features: &[String],
+) -> Result<(), String> {
     if backend == "interp" {
         let mut eval = tishlang_eval::Evaluator::new();
         let value = eval.eval_program(program)?;
@@ -229,14 +219,22 @@ fn run_program(program: &tishlang_ast::Program, backend: &str, no_optimize: bool
     } else {
         tishlang_bytecode::compile(program).map_err(|e| e.to_string())?
     };
-    let value = tishlang_vm::run(&chunk)?;
+    let caps = vm_capabilities_for_cli_run(features);
+    let value = tishlang_vm::run_with_options(
+        &chunk,
+        tishlang_vm::VmRunOptions {
+            repl_mode: false,
+            capabilities: caps,
+        },
+    )?;
     if !matches!(value, tishlang_core::Value::Null) {
         println!("{}", tishlang_core::format_value_styled(&value, tishlang_core::use_console_colors()));
     }
     Ok(())
 }
 
-fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
+fn run_repl(backend: &str, no_optimize: bool, features: &[String]) -> Result<(), String> {
+    cli_help::print_tish_banner();
     println!("Tish REPL (Ctrl-D to exit)");
     let mut buffer = String::new();
 
@@ -293,7 +291,9 @@ fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
     if !std::io::stdin().is_terminal() {
         eprintln!("Note: Tab completion and grey preview require an interactive terminal (TTY).");
     }
-    let vm = Rc::new(RefCell::new(tishlang_vm::Vm::new()));
+    let vm = Rc::new(RefCell::new(tishlang_vm::Vm::with_capabilities(
+        vm_capabilities_for_cli_run(features),
+    )));
     let completer = repl_completion::ReplCompleter {
         vm: Rc::clone(&vm),
         no_optimize,
@@ -333,7 +333,7 @@ fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
                             tishlang_bytecode::compile_for_repl
                         };
                         if let Ok(chunk) = compile_fn(&program) {
-                            let _ = vm.borrow_mut().run(&chunk);
+                            let _ = vm.borrow_mut().run_with_options(&chunk, true);
                         }
                     }
                     Err(e) => eprintln!("Parse error: {}", e),
@@ -365,7 +365,7 @@ fn run_repl(backend: &str, no_optimize: bool) -> Result<(), String> {
                 };
                 match compile_fn(&program) {
                     Ok(chunk) => {
-                        match vm.borrow_mut().run(&chunk) {
+                        match vm.borrow_mut().run_with_options(&chunk, true) {
                             Ok(v) => {
                                 if !matches!(v, tishlang_core::Value::Null) {
                                     println!("{}", tishlang_core::format_value_styled(&v, tishlang_core::use_console_colors()));
@@ -531,23 +531,7 @@ fn build_file(
             p
         }
     });
-    let features: Vec<String> = if cli_features.is_empty() {
-        #[allow(unused_mut)]
-        let mut f = Vec::new();
-        #[cfg(feature = "http")]
-        f.push("http".to_string());
-        #[cfg(feature = "fs")]
-        f.push("fs".to_string());
-        #[cfg(feature = "process")]
-        f.push("process".to_string());
-        #[cfg(feature = "regex")]
-        f.push("regex".to_string());
-        #[cfg(feature = "ws")]
-        f.push("ws".to_string());
-        f
-    } else {
-        cli_features.to_vec()
-    };
+    let features: Vec<String> = native_build_features_from_cli(cli_features);
 
     if is_js {
         let source = fs::read_to_string(&input_path).map_err(|e| format!("{}", e))?;
@@ -592,7 +576,9 @@ fn build_file(
 mod cli_tests {
     use clap::Parser;
 
-    use super::{argv_with_implicit_run, Cli, Commands};
+    use crate::cli_help::{Cli, Commands};
+
+    use super::argv_with_implicit_run;
 
     #[test]
     fn implicit_run_inserts_run_before_file() {

package/crates/tish/src/repl_completion.rs

@@ -86,7 +86,7 @@ impl ReplCompleter {
             compile_for_repl
         };
         let chunk = compile_fn(&program).ok()?;
-        let value = self.vm.borrow_mut().run(&chunk).ok()?;
+        let value = self.vm.borrow_mut().run_with_options(&chunk, true).ok()?;
 
         let keys = value.completion_keys();
         let filtered: Vec<String> = keys

package/crates/tish/tests/integration_test.rs

@@ -521,6 +521,54 @@ fn test_mvp_programs_interpreter() {
     }
 }
 
+/// Default bytecode VM must match the tree-walking interpreter for every MVP program.
+#[test]
+fn test_mvp_programs_interp_vm_stdout_parity() {
+    let core_dir = core_dir();
+    let bin = tish_bin();
+    assert!(
+        bin.exists(),
+        "tish binary not found at {}. Run `cargo build -p tishlang` first.",
+        bin.display()
+    );
+    for name in MVP_TEST_FILES {
+        let path = core_dir.join(name);
+        if !path.exists() {
+            continue;
+        }
+        let path_str = path.to_string_lossy();
+        let out_interp = Command::new(&bin)
+            .args(["run", path_str.as_ref(), "--backend", "interp"])
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish interpreter");
+        assert!(
+            out_interp.status.success(),
+            "Interpreter failed for {}: {}",
+            path.display(),
+            String::from_utf8_lossy(&out_interp.stderr)
+        );
+        let out_vm = Command::new(&bin)
+            .args(["run", path_str.as_ref()])
+            .current_dir(workspace_root())
+            .output()
+            .expect("run tish VM");
+        assert!(
+            out_vm.status.success(),
+            "VM failed for {}: {}",
+            path.display(),
+            String::from_utf8_lossy(&out_vm.stderr)
+        );
+        let s_interp = String::from_utf8_lossy(&out_interp.stdout);
+        let s_vm = String::from_utf8_lossy(&out_vm.stdout);
+        assert_eq!(
+            s_interp, s_vm,
+            "interp vs VM stdout mismatch for {}",
+            path.display()
+        );
+    }
+}
+
 /// Compile each .tish file to native, run, and compare stdout to static expected (parallelized).
 #[test]
 fn test_mvp_programs_native() {

package/crates/tish_build_utils/src/lib.rs

@@ -15,6 +15,123 @@ fn is_tish_workspace_root(root: &Path) -> bool {
     root.join("crates").join("tish_runtime").is_dir()
 }
 
+/// True if `line` (trimmed) opens a Cargo.toml table whose body may contain path dependencies.
+fn cargo_section_may_contain_path_deps(header: &str) -> bool {
+    let h = header.trim();
+    if h == "dependencies"
+        || h == "dev-dependencies"
+        || h == "build-dependencies"
+        || h == "workspace.dependencies"
+    {
+        return true;
+    }
+    h.starts_with("dependencies.")
+        || h.starts_with("dev-dependencies.")
+        || h.starts_with("build-dependencies.")
+        || h.starts_with("workspace.dependencies.")
+        || h.starts_with("patch.")
+}
+
+/// Collect `path = "..."` / `path = '...'` strings from lines in dependency-related sections.
+fn path_values_from_cargo_toml(content: &str) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut in_section = false;
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if let Some(rest) = trimmed.strip_prefix('[').and_then(|s| s.strip_suffix(']')) {
+            in_section = cargo_section_may_contain_path_deps(rest);
+            continue;
+        }
+        if !in_section {
+            continue;
+        }
+        extract_path_assignments_from_line(trimmed, &mut out);
+    }
+    out
+}
+
+fn extract_path_assignments_from_line(line: &str, out: &mut Vec<String>) {
+    let mut rest = line;
+    while let Some(idx) = rest.find("path") {
+        let after = rest[idx + 4..].trim_start();
+        let after = match after.strip_prefix('=') {
+            Some(a) => a.trim_start(),
+            None => {
+                rest = &rest[idx + 4..];
+                continue;
+            }
+        };
+        let quote = match after.chars().next() {
+            Some('"') => '"',
+            Some('\'') => '\'',
+            _ => {
+                rest = &rest[idx + 4..];
+                continue;
+            }
+        };
+        let after = &after[quote.len_utf8()..];
+        let end = after.find(quote);
+        let Some(end) = end else {
+            rest = &rest[idx + 4..];
+            continue;
+        };
+        out.push(after[..end].to_string());
+        rest = &after[end + quote.len_utf8()..];
+    }
+}
+
+/// Starting from a filesystem path (crate dir or file), walk ancestors for `crates/tish_runtime`.
+fn tish_root_from_path_hint(start: &Path) -> Option<PathBuf> {
+    let mut dir = if start.is_file() {
+        start.parent()?.to_path_buf()
+    } else {
+        start.to_path_buf()
+    };
+    dir = fs::canonicalize(&dir).unwrap_or(dir);
+    let mut cur = dir.as_path();
+    for _ in 0..32 {
+        if is_tish_workspace_root(cur) {
+            return Some(cur.to_path_buf());
+        }
+        cur = cur.parent()?;
+    }
+    None
+}
+
+/// Scan `dir/Cargo.toml` for path dependencies; if any resolves inside a Tish workspace, return that root.
+fn tish_root_from_cargo_manifest_dir(dir: &Path) -> Option<PathBuf> {
+    let cargo_toml = dir.join("Cargo.toml");
+    if !cargo_toml.is_file() {
+        return None;
+    }
+    let content = fs::read_to_string(&cargo_toml).ok()?;
+    let base = dir;
+    for rel in path_values_from_cargo_toml(&content) {
+        let joined = base.join(&rel);
+        let resolved = match joined.canonicalize() {
+            Ok(p) => p,
+            Err(_) => continue,
+        };
+        if let Some(root) = tish_root_from_path_hint(&resolved) {
+            return Some(root);
+        }
+    }
+    None
+}
+
+/// Walk from `start` upward; at each directory try [`tish_root_from_cargo_manifest_dir`].
+fn tish_root_from_project_cargo_files(mut start: PathBuf) -> Option<PathBuf> {
+    for _ in 0..32 {
+        if let Some(root) = tish_root_from_cargo_manifest_dir(&start) {
+            return Some(root);
+        }
+        if !start.pop() {
+            break;
+        }
+    }
+    None
+}
+
 /// Find the Tish workspace root using multiple strategies.
 ///
 /// Returns the directory containing the workspace Cargo.toml (with [workspace]).
@@ -30,6 +147,10 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
                 return Ok(root_buf);
             }
         }
+        // Consumer workspace: manifest is the app crate; path deps point at Tish checkout.
+        if let Some(root) = tish_root_from_project_cargo_files(path.clone()) {
+            return Ok(root);
+        }
     }
 
     // Strategy 2: Walk from current executable (e.g. target/debug/tish)
@@ -49,7 +170,14 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
         }
     }
 
-    // Strategy 3: Walk from current working directory
+    // Strategy 3: Walk from current working directory (path deps on a consumer crate)
+    if let Ok(cwd) = std::env::current_dir() {
+        if let Some(root) = tish_root_from_project_cargo_files(cwd.clone()) {
+            return Ok(root);
+        }
+    }
+
+    // Strategy 4: Walk from current working directory
     if let Ok(mut current) = std::env::current_dir() {
         for _ in 0..15 {
             let cargo_toml = current.join("Cargo.toml");
@@ -193,3 +321,45 @@ pub fn copy_binary_to_output(binary: &Path, output_path: &Path) -> Result<(), St
     fs::copy(binary, output_path).map_err(|e| format!("Cannot copy to {}: {}", output_path.display(), e))?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn path_values_dependencies_section_only() {
+        let toml = r#"
+[package]
+name = "app"
+path = "ignored-outside-deps"
+
+[dependencies]
+tishlang_runtime = { path = "../tish/crates/tish_runtime" }
+
+[metadata]
+path = "also-ignored"
+"#;
+        let paths = path_values_from_cargo_toml(toml);
+        assert_eq!(paths, vec!["../tish/crates/tish_runtime"]);
+    }
+
+    #[test]
+    fn path_values_workspace_dependencies() {
+        let toml = r#"
+[workspace.dependencies]
+tishlang_runtime = { path = "../../tish/tish/crates/tish_runtime" }
+"#;
+        let paths = path_values_from_cargo_toml(toml);
+        assert_eq!(paths, vec!["../../tish/tish/crates/tish_runtime"]);
+    }
+
+    #[test]
+    fn path_values_patch_section() {
+        let toml = r#"
+[patch.crates-io]
+tishlang_runtime = { path = "../vendor/tish_runtime" }
+"#;
+        let paths = path_values_from_cargo_toml(toml);
+        assert_eq!(paths, vec!["../vendor/tish_runtime"]);
+    }
+}