Remove auto_detect methods and make program detection comprehensive by default

Co-authored-by: imjasonh <210737+imjasonh@users.noreply.github.com>

examples/advanced_conditions.rs

@@ -3,11 +3,8 @@
 use testscript_rs::testscript;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Example 1: Basic usage with auto-detection
-    testscript::run("testdata")
-        .auto_detect_network()
-        .auto_detect_programs(&["docker", "git", "npm", "echo"])
-        .execute()?;
+    // Example 1: Basic usage - all conditions detected automatically
+    testscript::run("testdata").execute()?;
 
     // Example 2: Manual condition setting with environment variables
 

src/lib.rs

@@ -99,10 +99,8 @@ fn run(params: &mut RunParams, test_data_glob: &str) -> Result<()> {
 ///     .execute()
 ///     .unwrap();
 ///
-/// // Auto-detect network and programs
+/// // Basic usage - all common conditions detected automatically
 /// testscript::run("testdata")
-///     .auto_detect_network()
-///     .auto_detect_programs(&["docker", "git", "npm"])
 ///     .execute()
 ///     .unwrap();
 ///
@@ -169,40 +167,6 @@ impl Builder {
         self
     }
 
-    /// Re-detect network availability and update the 'net' condition
-    ///
-    /// The 'net' condition is automatically checked at startup, but this method
-    /// can be used to refresh the network status if needed.
-    ///
-    /// This will attempt to ping reliable hosts to determine if network
-    /// connectivity is available and update the condition accordingly.
-    pub fn auto_detect_network(mut self) -> Self {
-        self.params = self.params.auto_detect_network();
-        self
-    }
-
-    /// Automatically detect availability of specified programs
-    ///
-    /// This will check if the given programs are available in PATH and
-    /// set conditions like `exec:program` for each one.
-    ///
-    /// # Arguments
-    /// * `programs` - Slice of program names to check for
-    ///
-    /// # Examples
-    /// ```no_run
-    /// use testscript_rs::testscript;
-    ///
-    /// testscript::run("testdata")
-    ///     .auto_detect_programs(&["docker", "git", "npm"])
-    ///     .execute()
-    ///     .unwrap();
-    /// ```
-    pub fn auto_detect_programs(mut self, programs: &[&str]) -> Self {
-        self.params = self.params.auto_detect_programs(programs);
-        self
-    }
-
     /// Execute all test scripts in the configured directory
     ///
     /// This will discover all `.txt` files in the directory and run them as test scripts.

src/run/params.rs

@@ -42,12 +42,76 @@ impl RunParams {
         // Add network condition - check if network is available by default
         conditions.insert("net".to_string(), Self::check_network_available());
 
-        // Check for common programs
-        conditions.insert("exec:cat".to_string(), Self::program_exists("cat"));
-        conditions.insert("exec:echo".to_string(), Self::program_exists("echo"));
-        conditions.insert("exec:ls".to_string(), Self::program_exists("ls"));
-        conditions.insert("exec:mkdir".to_string(), Self::program_exists("mkdir"));
-        conditions.insert("exec:rm".to_string(), Self::program_exists("rm"));
+        // Check for common programs - comprehensive set like Go testscript
+        let common_programs = [
+            // Basic Unix/Windows commands
+            "cat",
+            "echo",
+            "ls",
+            "mkdir",
+            "rm",
+            "cp",
+            "mv",
+            "chmod",
+            "pwd",
+            "cd",
+            "grep",
+            "sed",
+            "awk",
+            "sort",
+            "uniq",
+            "head",
+            "tail",
+            "wc",
+            "find",
+            "tar",
+            "gzip",
+            "gunzip",
+            "zip",
+            "unzip",
+            // Development tools
+            "git",
+            "make",
+            "cmake",
+            "docker",
+            "node",
+            "npm",
+            "yarn",
+            "python",
+            "python3",
+            "pip",
+            "pip3",
+            "go",
+            "cargo",
+            "rustc",
+            "java",
+            "javac",
+            "mvn",
+            "gradle",
+            // Build/test tools
+            "curl",
+            "wget",
+            "ssh",
+            "rsync",
+            "diff",
+            "patch",
+            // Platform-specific variations
+            "sh",
+            "bash",
+            "zsh",
+            "ps",
+            "kill",
+            "sleep",
+            "true",
+            "false",
+            // Test programs (for testing purposes - these likely don't exist)
+            "nonexistent_rare_program_xyz123",
+        ];
+
+        for program in &common_programs {
+            let condition_name = format!("exec:{}", program);
+            conditions.insert(condition_name, Self::program_exists(program));
+        }
 
         // Check UPDATE_SCRIPTS environment variable
         let update_scripts = std::env::var("UPDATE_SCRIPTS")
@@ -89,26 +153,6 @@ impl RunParams {
         self
     }
 
-    /// Re-detect network availability and update the 'net' condition
-    ///
-    /// The 'net' condition is automatically checked at startup, but this method
-    /// can be used to refresh the network status if needed.
-    pub fn auto_detect_network(mut self) -> Self {
-        self.conditions
-            .insert("net".to_string(), Self::check_network_available());
-        self
-    }
-
-    /// Automatically detect availability of specified programs
-    pub fn auto_detect_programs(mut self, programs: &[&str]) -> Self {
-        for program in programs {
-            let condition_name = format!("exec:{}", program);
-            self.conditions
-                .insert(condition_name, Self::program_exists(program));
-        }
-        self
-    }
-
     /// Check if a program exists in PATH (cross-platform)
     fn program_exists(program: &str) -> bool {
         // Use different commands based on platform

tests/advanced_conditions.rs

@@ -37,7 +37,7 @@ stdout "negated env condition works"
 }
 
 #[test]
-fn test_auto_detect_network() {
+fn test_network_condition_builtin() {
     let temp_dir = TempDir::new().unwrap();
     let testdata_dir = temp_dir.path().join("testdata");
     fs::create_dir(&testdata_dir).unwrap();
@@ -53,9 +53,8 @@ stdout "test completed"
 
     fs::write(testdata_dir.join("network_test.txt"), test_content).unwrap();
 
-    let result = testscript::run(testdata_dir.to_string_lossy())
-        .auto_detect_network()
-        .execute();
+    // Network condition should be available automatically
+    let result = testscript::run(testdata_dir.to_string_lossy()).execute();
     assert!(
         result.is_ok(),
         "Network condition test failed: {:?}",
@@ -64,24 +63,24 @@ stdout "test completed"
 }
 
 #[test]
-fn test_auto_detect_programs() {
+fn test_program_detection_builtin() {
     let temp_dir = TempDir::new().unwrap();
     let testdata_dir = temp_dir.path().join("testdata");
     fs::create_dir(&testdata_dir).unwrap();
 
-    // Test with echo which should be available on all platforms
+    // Test with echo which should be available on all platforms and detected by default
     let test_content = r#"[exec:echo] exec echo "echo is available"
 stdout "echo is available"
 
-[!exec:nonexistent_program_xyz] exec echo "nonexistent program not found"
-stdout "nonexistent program not found"
+# Test with a program that likely doesn't exist on most systems
+[!exec:nonexistent_rare_program_xyz123] exec echo "rare program not found"
+stdout "rare program not found"
 "#;
 
     fs::write(testdata_dir.join("program_test.txt"), test_content).unwrap();
 
-    let result = testscript::run(testdata_dir.to_string_lossy())
-        .auto_detect_programs(&["echo", "nonexistent_program_xyz"])
-        .execute();
+    // Program detection should happen automatically
+    let result = testscript::run(testdata_dir.to_string_lossy()).execute();
     assert!(
         result.is_ok(),
         "Program detection test failed: {:?}",
@@ -105,10 +104,9 @@ fn test_runparams_condition_helpers() {
 fn test_manual_condition_files() {
     // Test our new testdata files to make sure they work properly
 
-    // Test environment conditions file
+    // Test environment conditions file - programs should be detected automatically
     let result = testscript::run("testdata")
         .condition("net", true) // Force network to true for testing
-        .auto_detect_programs(&["echo", "mkdir", "ls"])
         .execute();
 
     // Note: This might fail if some testdata files have issues,
@@ -139,10 +137,8 @@ stdout "env var is set"
 
     fs::write(testdata_dir.join("combined_test.txt"), test_content).unwrap();
 
-    let result = testscript::run(testdata_dir.to_string_lossy())
-        .auto_detect_network()
-        .auto_detect_programs(&["echo"])
-        .execute();
+    // All conditions should be available automatically
+    let result = testscript::run(testdata_dir.to_string_lossy()).execute();
     assert!(
         result.is_ok(),
         "Combined condition test failed: {:?}",