fix: duplicate versions and validation in mise tool

e2e/cli/test_tool

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Test valid tool information
+mise tool node | grep -q "Backend:" || fail "Backend field not found"
+
+# Test JSON output
+mise tool node --json | grep -q '"backend"' || fail "JSON backend field not found"
+
+# Test specific field filters
+backend_output=$(mise tool node --backend)
+[[ -n $backend_output ]] || fail "Backend output is empty"
+
+# Test that invalid tool names should error
+assert_fail "mise tool INVALID_TOOL_NAME"
+
+# Test duplicate version bug - install multiple versions of a tool
+mise use tiny@1.0.0
+mise use tiny@1.1.0
+assert "mise tool tiny --installed" "1.0.0 1.1.0"

src/cli/tool.rs

@@ -1,3 +1,4 @@
+use crate::ui::style;
 use eyre::Result;
 use itertools::Itertools;
 use serde_derive::Serialize;
@@ -61,7 +62,19 @@ impl Tool {
         let tvl = ts.versions.get(&self.tool);
         let tv = tvl.map(|tvl| tvl.versions.first().unwrap());
         let ba = tv.map(|tv| tv.ba()).unwrap_or_else(|| &self.tool);
-        let backend = ba.backend().ok();
+
+        // Check if the backend exists and fail if it doesn't
+        let backend = match ba.backend() {
+            Ok(b) => Some(b),
+            Err(e) => {
+                // If no versions are configured for this tool, it's likely invalid
+                if tvl.is_none() {
+                    return Err(e);
+                }
+                None
+            }
+        };
+
         let description = if let Some(backend) = backend {
             backend.description().await
         } else {
@@ -76,6 +89,7 @@ impl Tool {
                 .into_iter()
                 .filter(|(b, _)| b.ba().as_ref() == ba)
                 .map(|(_, tv)| tv.version)
+                .unique()
                 .collect::<Vec<_>>(),
             active_versions: tvl.map(|tvl| {
                 tvl.versions
@@ -137,7 +151,23 @@ impl Tool {
                 miseprintln!("[none]");
             }
         } else if self.filter.installed {
-            miseprintln!("{}", info.installed_versions.join(" "));
+            let active_set = info
+                .active_versions
+                .as_ref()
+                .map(|v| v.iter().collect::<std::collections::HashSet<_>>())
+                .unwrap_or_default();
+            let installed_with_bold = info
+                .installed_versions
+                .iter()
+                .map(|v| {
+                    if active_set.contains(v) {
+                        style::nbold(v).to_string()
+                    } else {
+                        v.to_string()
+                    }
+                })
+                .join(" ");
+            miseprintln!("{}", installed_with_bold);
         } else if self.filter.active {
             if let Some(active_versions) = info.active_versions {
                 miseprintln!("{}", active_versions.join(" "));
@@ -170,9 +200,29 @@ impl Tool {
             if let Some(description) = info.description {
                 table.push(("Description:", description));
             }
-            table.push(("Installed Versions:", info.installed_versions.join(" ")));
+            // Bold currently active versions within the installed list for clarity
+            let active_set = info
+                .active_versions
+                .as_ref()
+                .map(|v| v.iter().collect::<std::collections::HashSet<_>>())
+                .unwrap_or_default();
+            let installed_with_bold = info
+                .installed_versions
+                .iter()
+                .map(|v| {
+                    if active_set.contains(v) {
+                        style::nbold(v).to_string()
+                    } else {
+                        v.to_string()
+                    }
+                })
+                .join(" ");
+            table.push(("Installed Versions:", installed_with_bold));
             if let Some(active_versions) = info.active_versions {
-                table.push(("Active Version:", active_versions.join(" ")));
+                table.push((
+                    "Active Version:",
+                    style::nbold(active_versions.join(" ")).to_string(),
+                ));
             }
             if let Some(requested_versions) = info.requested_versions {
                 table.push(("Requested Version:", requested_versions.join(" ")));

src/toolset/mod.rs

@@ -502,11 +502,12 @@ impl Toolset {
             for v in b.list_installed_versions() {
                 if let Some((p, tv)) = current_versions.get(&(b.id().into(), v.clone())) {
                     versions.push((p.clone(), tv.clone()));
+                } else {
+                    let tv = ToolRequest::new(b.ba().clone(), &v, ToolSource::Unknown)?
+                        .resolve(config, &Default::default())
+                        .await?;
+                    versions.push((b.clone(), tv));
                 }
-                let tv = ToolRequest::new(b.ba().clone(), &v, ToolSource::Unknown)?
-                    .resolve(config, &Default::default())
-                    .await?;
-                versions.push((b.clone(), tv));
             }
         }
         Ok(versions)

src/ui/style.rs

@@ -55,6 +55,10 @@ pub fn ebold<D>(val: D) -> StyledObject<D> {
     estyle(val).bold()
 }
 
+pub fn nbold<D>(val: D) -> StyledObject<D> {
+    nstyle(val).bold()
+}
+
 pub fn epath(path: &Path) -> StyledObject<String> {
     estyle(display_path(path))
 }