vs-core 0.0.1

Core orchestration services for the vs version 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

use crate::{App, CoreError, CurrentTool};

impl App {
    /// Resolves the active version for a specific plugin.
    pub fn current_tool(&self, plugin_name: &str) -> Result<Option<CurrentTool>, CoreError> {
        let resolved = vs_config::resolve_tool_version(
            self.home(),
            &self.cwd,
            self.session_id.as_deref(),
            plugin_name,
        )?;
        let Some(resolved) = resolved else {
            return Ok(None);
        };
        if self
            .load_installed_runtime(&resolved.plugin, &resolved.version)?
            .is_none()
        {
            return Ok(None);
        }
        Ok(Some(CurrentTool {
            plugin: resolved.plugin,
            version: resolved.version,
            scope: resolved.scope,
            source: resolved.source,
        }))
    }

    /// Resolves all active tools for the current context.
    pub fn current_tools(&self) -> Result<Vec<CurrentTool>, CoreError> {
        let mut current = Vec::new();
        for configured in self.collect_current_tools()? {
            if self
                .load_installed_runtime(&configured.plugin, &configured.version)?
                .is_some()
            {
                current.push(configured);
            }
        }
        Ok(current)
    }

    /// Returns all known plugins with their current version when available.
    pub fn current_tool_statuses(&self) -> Result<Vec<(String, Option<String>)>, CoreError> {
        let mut names = self
            .added_plugins()?
            .into_iter()
            .map(|entry| entry.name)
            .collect::<std::collections::BTreeSet<_>>();
        names.extend(
            self.list_installed_versions()?
                .into_iter()
                .map(|installed| installed.plugin),
        );

        let mut statuses = Vec::new();
        for plugin in names {
            let current = self.current_tool(&plugin)?;
            statuses.push((plugin, current.map(|tool| tool.version)));
        }
        Ok(statuses)
    }
}