feat: add --include-path/-I flag for module resolution

Author: cablehead

README.md

@@ -61,6 +61,7 @@
   - [Syntax Highlighting](#syntax-highlighting)
   - [Streaming Input](#streaming-input)
   - [Plugins](#plugins)
+  - [Module Paths](#module-paths)
   - [Embedded Modules](#embedded-modules)
     - [Routing](#routing)
     - [HTML DSL](#html-dsl)
@@ -670,6 +671,14 @@ $ http-nu --plugin ~/.cargo/bin/nu_plugin_inc eval -c '1 | inc'
 2
 ```
 
+### Module Paths
+
+Make module paths available with `-I` / `--include-path`:
+
+```bash
+$ http-nu -I ./lib -I ./vendor :3001 '{|req| use mymod.nu; ...}'
+```
+
 ### Embedded Modules
 
 #### Routing

src/engine.rs

@@ -12,7 +12,8 @@ use nu_protocol::format_cli_error;
 use nu_protocol::{
     debugger::WithoutDebug,
     engine::{Closure, EngineState, Redirection, Stack, StateWorkingSet},
-    OutDest, PipelineData, PluginIdentity, RegisteredPlugin, ShellError, Signals, Span, Value,
+    OutDest, PipelineData, PluginIdentity, RegisteredPlugin, ShellError, Signals, Span, Type,
+    Value,
 };
 
 use crate::commands::{
@@ -180,6 +181,29 @@ impl Engine {
         self.state.set_signals(Signals::new(interrupt));
     }
 
+    /// Sets NU_LIB_DIRS const for module resolution
+    pub fn set_lib_dirs(&mut self, paths: &[std::path::PathBuf]) -> Result<(), Error> {
+        if paths.is_empty() {
+            return Ok(());
+        }
+        let span = Span::unknown();
+        let vals: Vec<Value> = paths
+            .iter()
+            .map(|p| Value::string(p.to_string_lossy(), span))
+            .collect();
+
+        let mut working_set = StateWorkingSet::new(&self.state);
+        let var_id = working_set.add_variable(
+            b"$NU_LIB_DIRS".into(),
+            span,
+            Type::List(Box::new(Type::String)),
+            false,
+        );
+        working_set.set_variable_const_val(var_id, Value::list(vals, span));
+        self.state.merge_delta(working_set.render())?;
+        Ok(())
+    }
+
     /// Evaluate a script string and return the result value
     pub fn eval(&self, script: &str) -> Result<Value, Error> {
         let mut working_set = StateWorkingSet::new(&self.state);

src/main.rs

@@ -54,6 +54,10 @@ struct Args {
     /// Trust proxies from these CIDR ranges for X-Forwarded-For parsing
     #[clap(long = "trust-proxy", value_name = "CIDR")]
     trust_proxies: Vec<ipnet::IpNet>,
+
+    /// Set NU_LIB_DIRS for module resolution (can be repeated)
+    #[clap(short = 'I', long = "include-path", global = true, value_name = "PATH")]
+    include_paths: Vec<PathBuf>,
 }
 
 #[derive(Clone, Debug, Default, clap::ValueEnum)]
@@ -81,9 +85,11 @@ enum Command {
 fn create_base_engine(
     interrupt: Arc<AtomicBool>,
     plugins: &[PathBuf],
+    include_paths: &[PathBuf],
 ) -> Result<Engine, Box<dyn std::error::Error + Send + Sync>> {
     let mut engine = Engine::new()?;
     engine.add_custom_commands()?;
+    engine.set_lib_dirs(include_paths)?;
 
     // Load plugins
     for plugin_path in plugins {
@@ -386,6 +392,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 
         let mut engine = Engine::new()?;
         engine.add_custom_commands()?;
+        engine.set_lib_dirs(&args.include_paths)?;
 
         for plugin_path in &args.plugins {
             engine.load_plugin(plugin_path)?;
@@ -411,7 +418,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let read_stdin = closure == "-";
 
     // Create base engine with commands, signals, and plugins
-    let base_engine = create_base_engine(interrupt.clone(), &args.plugins)?;
+    let base_engine = create_base_engine(interrupt.clone(), &args.plugins, &args.include_paths)?;
 
     // Create channel for scripts
     let (tx, rx) = mpsc::channel::<String>(1);

tests/eval_test.rs

@@ -1,7 +1,7 @@
 use assert_cmd::cargo::cargo_bin;
 use assert_cmd::Command;
 use std::io::Write;
-use tempfile::NamedTempFile;
+use tempfile::{NamedTempFile, TempDir};
 
 #[test]
 fn test_eval_commands_flag() {
@@ -108,3 +108,46 @@ fn test_eval_with_plugin() {
         .success()
         .stdout("PLUGIN_WORKS\n");
 }
+
+#[test]
+fn test_eval_include_path() {
+    let dir = TempDir::new().unwrap();
+    let module_path = dir.path().join("mymod.nu");
+    std::fs::write(&module_path, "export def hello [] { 'world' }").unwrap();
+
+    Command::cargo_bin("http-nu")
+        .unwrap()
+        .args([
+            "-I",
+            dir.path().to_str().unwrap(),
+            "eval",
+            "-c",
+            "use mymod.nu; mymod hello",
+        ])
+        .assert()
+        .success()
+        .stdout("world\n");
+}
+
+#[test]
+fn test_eval_include_path_multiple() {
+    let dir1 = TempDir::new().unwrap();
+    let dir2 = TempDir::new().unwrap();
+    std::fs::write(dir1.path().join("mod1.nu"), "export def a [] { 1 }").unwrap();
+    std::fs::write(dir2.path().join("mod2.nu"), "export def b [] { 2 }").unwrap();
+
+    Command::cargo_bin("http-nu")
+        .unwrap()
+        .args([
+            "-I",
+            dir1.path().to_str().unwrap(),
+            "-I",
+            dir2.path().to_str().unwrap(),
+            "eval",
+            "-c",
+            "use mod1.nu; use mod2.nu; (mod1 a) + (mod2 b)",
+        ])
+        .assert()
+        .success()
+        .stdout("3\n");
+}