feat: add mamba/micromamba manager detection and reporting (Fixes #25) (#350)

Adds mamba/micromamba manager detection alongside conda, so both
managers are reported when present.

**Key changes:**
- Add `Mamba` variant to `EnvManagerType` enum
- Detect mamba/micromamba binaries in conda install directories and
report as separate managers
- Auto-detect when `condaExecutable` points to a mamba binary (backwards
compatibility)
- Discover mamba/micromamba on PATH for environment location discovery
- Fall back to mamba when conda binary is unavailable for missing env
detection
- Update JSONRPC docs with `Mamba` manager type

Environments remain `PythonEnvironmentKind::Conda` — only the manager
reporting changes.

Fixes #25

Author: karthiknadig

crates/pet-conda/src/environment_locations.rs

@@ -4,7 +4,7 @@
 use crate::{
     conda_rc::{get_conda_rc_search_paths, Condarc},
     env_variables::EnvVariables,
-    manager::find_conda_binary,
+    manager::{find_conda_binary, find_mamba_binary},
     utils::{is_conda_env, is_conda_install},
 };
 use log::trace;
@@ -372,6 +372,10 @@ pub fn get_known_conda_install_locations(
     if let Some(conda_dir) = get_conda_dir_from_exe(&conda_from_path) {
         known_paths.push(conda_dir);
     }
+    // Also check for mamba/micromamba on PATH to discover its install directory
+    if let Some(mamba_dir) = get_conda_dir_from_exe(&find_mamba_binary(env_vars)) {
+        known_paths.push(mamba_dir);
+    }
     known_paths.sort();
     known_paths.dedup();
 
@@ -456,6 +460,10 @@ pub fn get_known_conda_install_locations(
     if let Some(conda_dir) = get_conda_dir_from_exe(&conda_from_path) {
         known_paths.push(conda_dir);
     }
+    // Also check for mamba/micromamba on PATH to discover its install directory
+    if let Some(mamba_dir) = get_conda_dir_from_exe(&find_mamba_binary(env_vars)) {
+        known_paths.push(mamba_dir);
+    }
     known_paths.sort();
     known_paths.dedup();
     known_paths.into_iter().filter(|f| f.exists()).collect()

crates/pet-conda/src/lib.rs

@@ -9,7 +9,7 @@ use environment_locations::{
 };
 use environments::{get_conda_environment_info, CondaEnvironment};
 use log::error;
-use manager::CondaManager;
+use manager::{get_mamba_manager, is_mamba_executable, CondaManager};
 use pet_core::{
     cache::LocatorCache,
     env::PythonEnv,
@@ -64,6 +64,7 @@ pub struct CondaTelemetryInfo {
 pub struct Conda {
     pub environments: Arc<LocatorCache<PathBuf, PythonEnvironment>>,
     pub managers: Arc<LocatorCache<PathBuf, CondaManager>>,
+    pub mamba_managers: Arc<LocatorCache<PathBuf, CondaManager>>,
     pub env_vars: EnvVariables,
     conda_executable: Arc<RwLock<Option<PathBuf>>>,
 }
@@ -73,13 +74,15 @@ impl Conda {
         Conda {
             environments: Arc::new(LocatorCache::new()),
             managers: Arc::new(LocatorCache::new()),
+            mamba_managers: Arc::new(LocatorCache::new()),
             env_vars: EnvVariables::from(env),
             conda_executable: Arc::new(RwLock::new(None)),
         }
     }
     fn clear(&self) {
         self.environments.clear();
         self.managers.clear();
+        self.mamba_managers.clear();
     }
 }
 
@@ -91,7 +94,12 @@ impl CondaLocator for Conda {
     ) -> Option<()> {
         // Look for environments that we couldn't find without spawning conda.
         let user_provided_conda_exe = conda_executable.is_some();
-        let conda_info = CondaInfo::from(conda_executable)?;
+        // Try the provided executable first (could be conda or mamba for backwards compat),
+        // then fall back to mamba/micromamba found on PATH if conda is unavailable.
+        let conda_info = CondaInfo::from(conda_executable).or_else(|| {
+            let mamba_exe = manager::find_mamba_binary(&self.env_vars);
+            CondaInfo::from(mamba_exe)
+        })?;
         let environments_map = self.environments.clone_map();
         let new_envs = conda_info
             .envs
@@ -159,6 +167,17 @@ impl CondaLocator for Conda {
                 // Possible we'll find environments in other directories created using this manager
                 self.managers.insert(conda_dir.clone(), manager.clone());
 
+                // Also check for a mamba/micromamba manager in the same directory and report it.
+                let _ = self
+                    .mamba_managers
+                    .get_or_insert_with(conda_dir.clone(), || {
+                        let mgr = get_mamba_manager(&conda_dir);
+                        if let Some(ref m) = mgr {
+                            reporter.report_manager(&m.to_manager());
+                        }
+                        mgr
+                    });
+
                 // Find all the environments in the conda install folder. (under `envs` folder)
                 for conda_env in
                     get_conda_environments(&get_environments(&conda_dir), &manager.clone().into())
@@ -272,6 +291,18 @@ impl Locator for Conda {
         let env_vars = self.env_vars.clone();
         let executable = self.conda_executable.read().unwrap().clone();
         thread::scope(|s| {
+            // If the user-provided conda_executable is actually a mamba/micromamba binary
+            // (backwards compatibility), report it as a mamba manager and discover its envs.
+            if let Some(ref exe) = executable {
+                if is_mamba_executable(exe) {
+                    if let Some(mamba_dir) = get_conda_dir_from_exe(&executable) {
+                        if let Some(mamba_mgr) = get_mamba_manager(&mamba_dir) {
+                            self.mamba_managers.insert(mamba_dir, mamba_mgr.clone());
+                            reporter.report_manager(&mamba_mgr.to_manager());
+                        }
+                    }
+                }
+            }
             // 1. Get a list of all know conda environments file paths
             let possible_conda_envs = get_conda_environment_paths(&env_vars, &executable);
             for path in possible_conda_envs {
@@ -318,6 +349,18 @@ impl Locator for Conda {
                         self.environments.insert(prefix.clone(), env.clone());
                         reporter.report_manager(&manager.to_manager());
                         reporter.report_environment(&env);
+
+                        // Also check for a mamba/micromamba manager in the same directory and report it.
+                        // Reporting inside the closure minimizes the TOCTOU window compared to a
+                        // separate contains_key check, though concurrent threads may still
+                        // briefly both invoke the closure before the write-lock double-check.
+                        let _ = self.mamba_managers.get_or_insert_with(conda_dir.clone(), || {
+                            let mgr = get_mamba_manager(conda_dir);
+                            if let Some(ref m) = mgr {
+                                reporter.report_manager(&m.to_manager());
+                            }
+                            mgr
+                        });
                     } else {
                         // We will still return the conda env even though we do not have the manager.
                         // This might seem incorrect, however the tool is about discovering environments.

crates/pet-conda/src/manager.rs

@@ -36,6 +36,34 @@ fn get_conda_executable(path: &Path) -> Option<PathBuf> {
     None
 }
 
+fn get_mamba_executable(path: &Path) -> Option<PathBuf> {
+    #[cfg(windows)]
+    let relative_paths = vec![
+        PathBuf::from("Scripts").join("mamba.exe"),
+        PathBuf::from("Scripts").join("mamba.bat"),
+        PathBuf::from("Scripts").join("micromamba.exe"),
+        PathBuf::from("Scripts").join("micromamba.bat"),
+        PathBuf::from("bin").join("mamba.exe"),
+        PathBuf::from("bin").join("mamba.bat"),
+        PathBuf::from("bin").join("micromamba.exe"),
+        PathBuf::from("bin").join("micromamba.bat"),
+    ];
+    #[cfg(unix)]
+    let relative_paths = vec![
+        PathBuf::from("bin").join("mamba"),
+        PathBuf::from("bin").join("micromamba"),
+    ];
+
+    for relative_path in relative_paths {
+        let exe = path.join(&relative_path);
+        if exe.exists() {
+            return Some(exe);
+        }
+    }
+
+    None
+}
+
 /// Specifically returns the file names that are valid for 'conda' on windows
 #[cfg(windows)]
 fn get_conda_bin_names() -> Vec<&'static str> {
@@ -48,6 +76,18 @@ fn get_conda_bin_names() -> Vec<&'static str> {
     vec!["conda"]
 }
 
+/// Specifically returns the file names that are valid for 'mamba'/'micromamba' on windows
+#[cfg(windows)]
+fn get_mamba_bin_names() -> Vec<&'static str> {
+    vec!["mamba.exe", "mamba.bat", "micromamba.exe", "micromamba.bat"]
+}
+
+/// Specifically returns the file names that are valid for 'mamba'/'micromamba' on linux/Mac
+#[cfg(unix)]
+fn get_mamba_bin_names() -> Vec<&'static str> {
+    vec!["mamba", "micromamba"]
+}
+
 /// Find the conda binary on the PATH environment variable
 pub fn find_conda_binary(env_vars: &EnvVariables) -> Option<PathBuf> {
     let paths = env_vars.path.clone()?;
@@ -62,17 +102,32 @@ pub fn find_conda_binary(env_vars: &EnvVariables) -> Option<PathBuf> {
     None
 }
 
+/// Find a mamba or micromamba binary on the PATH environment variable
+pub fn find_mamba_binary(env_vars: &EnvVariables) -> Option<PathBuf> {
+    let paths = env_vars.path.clone()?;
+    for path in env::split_paths(&paths) {
+        for bin in get_mamba_bin_names() {
+            let mamba_path = path.join(bin);
+            if mamba_path.is_file() || mamba_path.is_symlink() {
+                return Some(mamba_path);
+            }
+        }
+    }
+    None
+}
+
 #[derive(Debug, Clone)]
 pub struct CondaManager {
     pub executable: PathBuf,
     pub version: Option<String>,
     pub conda_dir: Option<PathBuf>,
+    pub manager_type: EnvManagerType,
 }
 
 impl CondaManager {
     pub fn to_manager(&self) -> EnvManager {
         EnvManager {
-            tool: EnvManagerType::Conda,
+            tool: self.manager_type,
             executable: self.executable.clone(),
             version: self.version.clone(),
         }
@@ -85,7 +140,9 @@ impl CondaManager {
         // If this environment is in a folder named `envs`, then the parent directory of `envs` is the root conda install folder.
         if let Some(parent) = path.ancestors().nth(2) {
             if is_conda_install(parent) {
-                if let Some(manager) = get_conda_manager(parent) {
+                if let Some(manager) =
+                    get_conda_manager(parent).or_else(|| get_mamba_manager(parent))
+                {
                     return Some(manager);
                 }
             }
@@ -98,6 +155,7 @@ impl CondaManager {
         // Or its in a location such as `~/.conda/envs` or `~/miniconda3/envs` where the conda install folder is not a parent of this path.
         if let Some(conda_install_folder) = get_conda_installation_used_to_create_conda_env(path) {
             get_conda_manager(&conda_install_folder)
+                .or_else(|| get_mamba_manager(&conda_install_folder))
         } else {
             // If this is a conda env and the parent is `.conda/envs`, then this is definitely NOT a root conda install folder.
             // Hence never use conda installs from these env paths.
@@ -111,19 +169,24 @@ impl CondaManager {
                 }
             }
 
-            if let Some(manager) = get_conda_manager(path) {
+            if let Some(manager) = get_conda_manager(path).or_else(|| get_mamba_manager(path)) {
                 Some(manager)
             } else {
-                trace!("No conda manager found for path: {:?}", path);
+                trace!("No conda or mamba manager found for path: {:?}", path);
                 None
             }
         }
     }
-    pub fn from_info(executable: &Path, info: &CondaInfo) -> Option<CondaManager> {
+    pub fn from_info(
+        executable: &Path,
+        info: &CondaInfo,
+        manager_type: EnvManagerType,
+    ) -> Option<CondaManager> {
         Some(CondaManager {
             executable: executable.to_path_buf(),
             version: Some(info.conda_version.clone()),
             conda_dir: info.conda_prefix.clone(),
+            manager_type,
         })
     }
 }
@@ -135,8 +198,32 @@ fn get_conda_manager(path: &Path) -> Option<CondaManager> {
             executable: conda_exe,
             version: Some(conda_pkg.version),
             conda_dir: Some(path.to_path_buf()),
+            manager_type: EnvManagerType::Conda,
         })
     } else {
         None
     }
 }
+
+/// Checks whether a given executable path refers to a mamba or micromamba binary.
+pub fn is_mamba_executable(exe: &Path) -> bool {
+    if let Some(name) = exe.file_name().and_then(|n| n.to_str()) {
+        let name = name.to_lowercase();
+        name.starts_with("mamba") || name.starts_with("micromamba")
+    } else {
+        false
+    }
+}
+
+pub(crate) fn get_mamba_manager(path: &Path) -> Option<CondaManager> {
+    let mamba_exe = get_mamba_executable(path)?;
+    // We cannot reliably determine the mamba/micromamba version from package metadata alone.
+    // The conda package version in conda-meta is the conda version, not the mamba version.
+    // Determining the mamba version would require spawning the mamba process.
+    Some(CondaManager {
+        executable: mamba_exe,
+        version: None,
+        conda_dir: Some(path.to_path_buf()),
+        manager_type: EnvManagerType::Mamba,
+    })
+}

crates/pet-conda/src/telemetry.rs

@@ -11,8 +11,12 @@ use pet_core::{
 };
 
 use crate::{
-    conda_info::CondaInfo, conda_rc::Condarc, env_variables::EnvVariables,
-    environments::get_conda_environment_info, manager::CondaManager, utils::is_conda_install,
+    conda_info::CondaInfo,
+    conda_rc::Condarc,
+    env_variables::EnvVariables,
+    environments::get_conda_environment_info,
+    manager::{is_mamba_executable, CondaManager},
+    utils::is_conda_install,
 };
 
 pub fn report_missing_envs(
@@ -221,7 +225,12 @@ fn log_and_find_missing_envs(
         .collect::<Vec<_>>();
 
     // Oh oh, we have new envs, lets see what they are.
-    let manager = CondaManager::from_info(&conda_info.executable, conda_info)?;
+    let manager_type = if is_mamba_executable(&conda_info.executable) {
+        pet_core::manager::EnvManagerType::Mamba
+    } else {
+        pet_core::manager::EnvManagerType::Conda
+    };
+    let manager = CondaManager::from_info(&conda_info.executable, conda_info, manager_type)?;
     for path in missing_envs
         .clone()
         .iter()