feat: add symlink resolution and version extraction for Homebrew Poetry

Author: karthiknadig

crates/pet-fs/src/path.rs

@@ -200,6 +200,33 @@ fn normalize_case_windows(path: &Path) -> Option<PathBuf> {
     Some(PathBuf::from(result_str))
 }
 
+/// Resolves any symlink to its real file path without filtering.
+///
+/// Returns `None` if the path is not a symlink or cannot be resolved.
+/// If the real file equals the input, returns `None` (the path is not a symlink).
+///
+/// # Use Cases
+/// - Resolving Homebrew symlinks for tools like Poetry: `/opt/homebrew/bin/poetry` → Cellar path
+/// - Generic symlink resolution where no filename filtering is needed
+///
+/// # Related
+/// - `resolve_symlink()` - Filtered version for Python/Conda executables only
+pub fn resolve_any_symlink<T: AsRef<Path>>(path: &T) -> Option<PathBuf> {
+    let metadata = std::fs::symlink_metadata(path).ok()?;
+    if metadata.is_file() || !metadata.file_type().is_symlink() {
+        return None;
+    }
+    if let Ok(readlink) = std::fs::canonicalize(path) {
+        if readlink == path.as_ref().to_path_buf() {
+            None
+        } else {
+            Some(readlink)
+        }
+    } else {
+        None
+    }
+}
+
 /// Resolves a symlink to its real file path.
 ///
 /// Returns `None` if the path is not a symlink or cannot be resolved.
@@ -217,6 +244,7 @@ fn normalize_case_windows(path: &Path) -> Option<PathBuf> {
 ///
 /// # Related
 /// - `norm_case()` - Normalizes path case without resolving symlinks
+/// - `resolve_any_symlink()` - Unfiltered version for any symlink
 pub fn resolve_symlink<T: AsRef<Path>>(exe: &T) -> Option<PathBuf> {
     let name = exe.as_ref().file_name()?.to_string_lossy();
     // In bin directory of homebrew, we have files like python-build, python-config, python3-config

crates/pet-poetry/src/manager.rs

@@ -1,22 +1,33 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+use lazy_static::lazy_static;
 use log::trace;
 use pet_core::manager::{EnvManager, EnvManagerType};
+use pet_fs::path::resolve_any_symlink;
+use regex::Regex;
 use std::{env, path::PathBuf};
 
 use crate::env_variables::EnvVariables;
 
+lazy_static! {
+    /// Matches Homebrew Cellar path for poetry: /Cellar/poetry/X.Y.Z or /Cellar/poetry/X.Y.Z_N
+    static ref HOMEBREW_POETRY_VERSION: Regex =
+        Regex::new(r"/Cellar/poetry/(\d+\.\d+\.\d+)").expect("error parsing Homebrew poetry version regex");
+}
+
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct PoetryManager {
     pub executable: PathBuf,
+    pub version: Option<String>,
 }
 
 impl PoetryManager {
     pub fn find(executable: Option<PathBuf>, env_variables: &EnvVariables) -> Option<Self> {
         if let Some(executable) = executable {
             if executable.is_file() {
-                return Some(PoetryManager { executable });
+                let version = Self::extract_version_from_path(&executable);
+                return Some(PoetryManager { executable, version });
             }
         }
 
@@ -107,7 +118,8 @@ impl PoetryManager {
             }
             for executable in search_paths {
                 if executable.is_file() {
-                    return Some(PoetryManager { executable });
+                    let version = Self::extract_version_from_path(&executable);
+                    return Some(PoetryManager { executable, version });
                 }
             }
 
@@ -116,12 +128,14 @@ impl PoetryManager {
                 for each in env::split_paths(env_path) {
                     let executable = each.join("poetry");
                     if executable.is_file() {
-                        return Some(PoetryManager { executable });
+                        let version = Self::extract_version_from_path(&executable);
+                        return Some(PoetryManager { executable, version });
                     }
                     if std::env::consts::OS == "windows" {
                         let executable = each.join("poetry.exe");
                         if executable.is_file() {
-                            return Some(PoetryManager { executable });
+                            let version = Self::extract_version_from_path(&executable);
+                            return Some(PoetryManager { executable, version });
                         }
                     }
                 }
@@ -130,10 +144,35 @@ impl PoetryManager {
         trace!("Poetry exe not found");
         None
     }
+
+    /// Extracts poetry version from Homebrew Cellar path.
+    ///
+    /// Homebrew installs poetry to paths like:
+    /// - macOS ARM: /opt/homebrew/Cellar/poetry/1.8.3_2/bin/poetry
+    /// - macOS Intel: /usr/local/Cellar/poetry/1.8.3/bin/poetry
+    /// - Linux: /home/linuxbrew/.linuxbrew/Cellar/poetry/1.8.3/bin/poetry
+    ///
+    /// The symlink at /opt/homebrew/bin/poetry points to the Cellar path.
+    fn extract_version_from_path(executable: &PathBuf) -> Option<String> {
+        // First try to resolve the symlink to get the actual Cellar path
+        let resolved = resolve_any_symlink(executable).unwrap_or_else(|| executable.clone());
+        let path_str = resolved.to_string_lossy();
+
+        // Check if this is a Homebrew Cellar path and extract version
+        if let Some(captures) = HOMEBREW_POETRY_VERSION.captures(&path_str) {
+            if let Some(version_match) = captures.get(1) {
+                let version = version_match.as_str().to_string();
+                trace!("Extracted Poetry version {} from Homebrew path: {:?}", version, resolved);
+                return Some(version);
+            }
+        }
+        None
+    }
+
     pub fn to_manager(&self) -> EnvManager {
         EnvManager {
             executable: self.executable.clone(),
-            version: None,
+            version: self.version.clone(),
             tool: EnvManagerType::Poetry,
         }
     }