make ext folder composable: load extensions from both global and local

Previously, ext/ used the same override logic as dist/ and jre/ - if local
.karate/ext/ existed, it replaced global ~/.karate/ext/. This made it
impossible to have project-specific extensions while keeping global ones.

Changes:
- platform.rs: add all_ext_dirs() method returning both global and local ext paths
- delegate.rs: update build_classpath() to iterate over all ext directories
- doctor.rs: update extensions list to show jars from all ext directories
- spec.md: clarify that ext/ is composable while dist/ and jre/ remain override

Behavior:
- dist/: local overrides global (unchanged)
- jre/: local overrides global (unchanged)
- ext/: both global AND local jars are loaded (new composable behavior)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: ptrthomas

docs/spec.md

@@ -403,11 +403,12 @@ Karate CLI uses a two-level resolution for resources (dist, jre, ext):
 - `.karate/` folder in current working directory
 
 **Resolution per resource:**
-- If `.karate/{resource}/` exists in cwd → use local
-- Otherwise → use global `{home}/{resource}/`
+- `dist/`: If `.karate/dist/` exists in cwd → use local, otherwise → use global
+- `jre/`: If `.karate/jre/` exists in cwd → use local, otherwise → use global
+- `ext/`: Extensions from BOTH global `~/.karate/ext/` AND local `.karate/ext/` are loaded (composable, not override)
 
 **Example:** A project with `.karate/ext/` but no `.karate/jre/`:
-- Extensions: loaded from `.karate/ext/` (local)
+- Extensions: loaded from BOTH `~/.karate/ext/` (global) AND `.karate/ext/` (local)
 - JRE: loaded from `~/.karate/jre/` (global fallback)
 - Dist: loaded from `~/.karate/dist/` (global fallback)
 

src/commands/doctor.rs

@@ -110,8 +110,12 @@ fn build_report() -> Result<DoctorReport> {
     // Karate JAR info
     let karate_jar = find_karate_jar(&paths);
 
-    // Extensions
-    let extensions = list_jars(&paths.ext);
+    // Extensions (from both global and local ext directories)
+    let extensions: Vec<String> = paths
+        .all_ext_dirs()
+        .iter()
+        .flat_map(|dir| list_jars(dir))
+        .collect();
 
     // Config info
     let local_config_path = KaratePaths::local_config();
@@ -292,16 +296,20 @@ fn print_report(report: &DoctorReport) {
 
     // Config
     println!("{}", style("Configuration").bold().underlined());
-    let global_status = if report.config.global_exists {
-        style("✓").green()
+    if report.config.global_exists {
+        println!("  Global: {} {}", style("✓").green(), report.config.global_path);
     } else {
-        style("-").dim()
-    };
-    let local_status = if report.config.local_exists {
-        style("✓").green()
+        println!(
+            "  Global: {}",
+            style(format!("(none) create with: karate config --global")).dim()
+        );
+    }
+    if report.config.local_exists {
+        println!("  Local:  {} {}", style("✓").green(), report.config.local_path);
     } else {
-        style("-").dim()
-    };
-    println!("  Global: {} {}", global_status, report.config.global_path);
-    println!("  Local:  {} {}", local_status, report.config.local_path);
+        println!(
+            "  Local:  {}",
+            style(format!("(none) create with: karate config --local")).dim()
+        );
+    }
 }

src/delegate.rs

@@ -115,13 +115,15 @@ fn find_karate_jar(dist_dir: &Path) -> Result<PathBuf> {
 fn build_classpath(paths: &KaratePaths, jar_path: &Path) -> Result<String> {
     let mut classpath_parts = vec![jar_path.to_string_lossy().to_string()];
 
-    // Add user extensions from ext/
-    if paths.ext.exists() {
-        for entry in std::fs::read_dir(&paths.ext)? {
-            let entry = entry?;
-            let path = entry.path();
-            if path.extension().map(|e| e == "jar").unwrap_or(false) {
-                classpath_parts.push(path.to_string_lossy().to_string());
+    // Add extensions from both global and local ext directories
+    for ext_dir in paths.all_ext_dirs() {
+        if ext_dir.exists() {
+            for entry in std::fs::read_dir(&ext_dir)? {
+                let entry = entry?;
+                let path = entry.path();
+                if path.extension().map(|e| e == "jar").unwrap_or(false) {
+                    classpath_parts.push(path.to_string_lossy().to_string());
+                }
             }
         }
     }

src/platform.rs

@@ -230,6 +230,19 @@ impl KaratePaths {
     pub fn has_local_overrides(&self) -> bool {
         self.local.is_some()
     }
+
+    /// Get all ext directories to check (global + optional local).
+    /// Extensions are composable: both global and local ext jars are loaded.
+    pub fn all_ext_dirs(&self) -> Vec<PathBuf> {
+        let mut dirs = vec![self.home.join("ext")];
+        if let Some(ref local) = self.local {
+            let local_ext = local.join("ext");
+            if local_ext.exists() {
+                dirs.push(local_ext);
+            }
+        }
+        dirs
+    }
 }
 
 impl Default for KaratePaths {