vx-cli 0.4.0

CLI interface for vx tool manager
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! List command implementation

use crate::ui::UI;
use anyhow::Result;
use vx_paths::{PathManager, PathResolver};
use vx_plugin::PluginRegistry;

pub async fn handle(
    registry: &PluginRegistry,
    tool: Option<&str>,
    show_status: bool,
) -> Result<()> {
    // Create path manager and resolver
    let path_manager = PathManager::new()
        .map_err(|e| anyhow::anyhow!("Failed to initialize path manager: {}", e))?;
    let resolver = PathResolver::new(path_manager);

    match tool {
        Some(tool_name) => {
            // List versions for a specific tool
            list_tool_versions(registry, &resolver, tool_name, show_status).await?;
        }
        None => {
            // List all tools
            list_all_tools(registry, &resolver, show_status).await?;
        }
    }
    Ok(())
}

async fn list_tool_versions(
    registry: &PluginRegistry,
    resolver: &PathResolver,
    tool_name: &str,
    show_status: bool,
) -> Result<()> {
    // Check if tool is supported
    let tool = registry.get_tool(tool_name);
    if tool.is_none() {
        UI::error(&format!("Tool '{}' is not supported", tool_name));
        UI::hint("Use 'vx list' to see all supported tools");
        return Ok(());
    }

    UI::info(&format!("📦 {}", tool_name));

    // Get installed versions
    let installed_versions = resolver.manager().list_tool_versions(tool_name)?;

    if installed_versions.is_empty() {
        UI::hint("  No versions installed");
        if show_status {
            UI::hint(&format!(
                "  Use 'vx install {}' to install this tool",
                tool_name
            ));
        }
        return Ok(());
    }

    // Show installed versions
    for version in &installed_versions {
        let status_icon = if show_status { "✅" } else { "  " };
        println!("  {} {}", status_icon, version);

        if show_status {
            let exe_path = resolver.manager().tool_executable_path(tool_name, version);
            println!("     📁 {}", exe_path.display());
        }
    }

    if show_status {
        UI::success(&format!(
            "Total: {} version(s) installed",
            installed_versions.len()
        ));
    }

    Ok(())
}

async fn list_all_tools(
    registry: &PluginRegistry,
    resolver: &PathResolver,
    show_status: bool,
) -> Result<()> {
    UI::info("📦 Available Tools:");

    // Get all supported tools from registry
    let supported_tools = registry.list_tools();

    // Get all installed tools
    let installed_tools = resolver.manager().list_installed_tools()?;

    for tool_name in &supported_tools {
        let is_installed = installed_tools.contains(tool_name);
        let status_icon = if is_installed { "✅" } else { "❌" };

        if let Some(tool) = registry.get_tool(tool_name) {
            println!("  {} {} - {}", status_icon, tool_name, tool.description());

            if show_status && is_installed {
                let versions = resolver.manager().list_tool_versions(tool_name)?;
                if !versions.is_empty() {
                    println!("     Versions: {}", versions.join(", "));
                }
            }
        }
    }

    // Show summary
    if show_status {
        let total_supported = supported_tools.len();
        let total_installed = installed_tools.len();
        UI::info(&format!(
            "\n📊 Summary: {}/{} tools installed",
            total_installed, total_supported
        ));
    }

    Ok(())
}