feat: improve recursive environment glob diagnostics (Fixes #427)

Warn before expanding recursive environmentDirectories and report exact per-pattern timings for slow configure globs.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: karthiknadig

crates/pet-fs/src/glob.rs

@@ -19,6 +19,10 @@ pub fn is_glob_pattern(path: &str) -> bool {
     path.contains(GLOB_METACHARACTERS) || has_brace_pattern(path)
 }
 
+/// Returns true when a glob can traverse an unbounded number of path components.
+pub fn is_recursive_glob_pattern(path: &str) -> bool {
+    path.contains("**")
+}
 /// Checks if a string contains a valid brace expansion pattern `{a,b}`.
 /// Requires an opening `{`, at least one `,`, and a closing `}`.
 fn has_brace_pattern(path: &str) -> bool {
@@ -202,6 +206,13 @@ mod tests {
         assert!(is_glob_pattern("*.txt"));
     }
 
+    #[test]
+    fn test_is_recursive_glob_pattern() {
+        assert!(is_recursive_glob_pattern("**/.venv"));
+        assert!(is_recursive_glob_pattern("/home/user/**/venv"));
+        assert!(!is_recursive_glob_pattern(".venv"));
+        assert!(!is_recursive_glob_pattern("*/.venv"));
+    }
     #[test]
     fn test_is_glob_pattern_with_question_mark() {
         assert!(is_glob_pattern("/home/user/file?.txt"));

crates/pet/src/jsonrpc.rs

@@ -21,7 +21,7 @@ use pet_core::{
     Configuration, Locator, RefreshStatePersistence, RefreshStateSyncScope,
 };
 use pet_env_var_path::get_search_paths_from_env_variables;
-use pet_fs::glob::expand_glob_patterns;
+use pet_fs::glob::{expand_glob_pattern, expand_glob_patterns, is_recursive_glob_pattern};
 use pet_fs::path::norm_case;
 use pet_jsonrpc::{
     send_error, send_reply,
@@ -566,6 +566,43 @@ pub struct ConfigureOptions {
 /// The client has a 30-second timeout for configure requests.
 const GLOB_EXPANSION_WARN_THRESHOLD: Duration = Duration::from_secs(5);
 
+fn expand_configure_directory_patterns(kind: &str, patterns: Vec<PathBuf>) -> Vec<PathBuf> {
+    patterns
+        .into_iter()
+        .flat_map(|pattern| {
+            let start = Instant::now();
+            let expanded = expand_glob_pattern(&pattern.to_string_lossy());
+            let elapsed = start.elapsed();
+            trace!(
+                "Expanded {} pattern '{}' in {:?}",
+                kind,
+                pattern.display(),
+                elapsed
+            );
+            if elapsed >= GLOB_EXPANSION_WARN_THRESHOLD {
+                warn!(
+                    "Expanding {} pattern '{}' took {:?}, this may cause client timeouts",
+                    kind,
+                    pattern.display(),
+                    elapsed
+                );
+            }
+            expanded
+        })
+        .filter(|path| path.is_dir())
+        .collect()
+}
+
+fn warn_for_recursive_environment_patterns(patterns: &[PathBuf]) {
+    for pattern in patterns {
+        if is_recursive_glob_pattern(&pattern.to_string_lossy()) {
+            warn!(
+                "Recursive environmentDirectories pattern '{}' can make configure slow; prefer bounded patterns such as '.venv' or '*/.venv'",
+                pattern.display()
+            );
+        }
+    }
+}
 pub fn handle_configure(context: Arc<Context>, id: u32, params: Value) {
     match serde_json::from_value::<ConfigureOptions>(params.clone()) {
         Ok(mut configure_options) => {
@@ -574,38 +611,28 @@ pub fn handle_configure(context: Arc<Context>, id: u32, params: Value) {
             thread::spawn(move || {
                 let now = Instant::now();
 
+                // Warn before any expansion so a slow workspace pattern cannot delay
+                // the actionable environmentDirectories diagnostic.
+                if let Some(patterns) = configure_options.environment_directories.as_deref() {
+                    warn_for_recursive_environment_patterns(patterns);
+                }
+
                 // Expand glob patterns before acquiring the write lock so we
                 // don't block readers/writers while traversing the filesystem.
                 let workspace_directories =
-                    configure_options.workspace_directories.take().map(|dirs| {
-                        let start = Instant::now();
-                        let result: Vec<PathBuf> = expand_glob_patterns(&dirs)
-                            .into_iter()
-                            .filter(|p| p.is_dir())
-                            .collect();
-                        trace!(
-                            "Expanded workspace directory patterns ({:?}) in {:?}",
-                            dirs,
-                            start.elapsed()
-                        );
-                        result
-                    });
+                    configure_options
+                        .workspace_directories
+                        .take()
+                        .map(|patterns| {
+                            expand_configure_directory_patterns("workspaceDirectories", patterns)
+                        });
                 let environment_directories =
                     configure_options
                         .environment_directories
                         .take()
-                        .map(|dirs| {
-                            let start = Instant::now();
-                            let result: Vec<PathBuf> = expand_glob_patterns(&dirs)
-                                .into_iter()
-                                .filter(|p| p.is_dir())
-                                .collect();
-                            trace!(
-                                "Expanded environment directory patterns ({:?}) in {:?}",
-                                dirs,
-                                start.elapsed()
-                            );
-                            result
+                        .map(|patterns| {
+                            warn_for_recursive_environment_patterns(&patterns);
+                            expand_configure_directory_patterns("environmentDirectories", patterns)
                         });
                 let glob_elapsed = now.elapsed();
                 trace!("Glob expansion completed in {:?}", glob_elapsed);

docs/JSONRPC.md

@@ -83,7 +83,9 @@ interface ConfigureParams {
    *
    * Useful for VS Code so users can configure where they store virtual environments.
    *
-   * Glob patterns are supported (e.g., "/home/user/envs/*", "/home/user/*/venv").
+   * Bounded glob patterns are supported (e.g., ".venv", "*/.venv", "/home/user/envs/*").
+   * Avoid recursive workspace-wide patterns such as "**/.venv": they can traverse large directory trees,
+   * delay configure responses, and trigger client timeouts.
    */
   environmentDirectories?: string[];
   /**