mise 2026.8.6

Dev tools, env vars, and tasks in one CLI
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

use std::collections::HashSet;

use crate::cli::args::ToolArg;
use crate::config::Config;
use crate::toolset::outdated_info::OutdatedInfo;
use crate::toolset::{ConfigScope, ResolveOptions, ToolsetBuilder};
use crate::ui::table;
use eyre::Result;
use indexmap::IndexMap;
use tabled::settings::Remove;
use tabled::settings::location::ByColumnName;

/// Shows outdated tool versions
///
/// See `mise upgrade` to upgrade these versions.
#[derive(Debug, clap::Args)]
#[clap(verbatim_doc_comment, after_long_help = AFTER_LONG_HELP)]
pub struct Outdated {
    /// Tool(s) to show outdated versions for
    /// e.g.: node@20 python@3.10
    /// If not specified, all tools in global and local configs will be shown
    #[clap(value_name = "TOOL@VERSION", verbatim_doc_comment)]
    pub tool: Vec<ToolArg>,

    /// Compares against the latest versions available, not what matches the current config
    ///
    /// For example, if you have `node = "20"` in your config by default `mise outdated` will only
    /// show other 20.x versions, not 21.x or 22.x versions.
    ///
    /// Using this flag, if there are 21.x or newer versions it will display those instead of 20.x.
    #[clap(long, short = 'b', verbatim_doc_comment)]
    pub bump: bool,

    /// Output in JSON format
    #[clap(short = 'J', long, verbatim_doc_comment)]
    pub json: bool,

    /// Deprecated shorthand for --bump
    #[clap(short = 'l', hide = true)]
    pub legacy_bump: bool,

    /// Show outdated tools including installed-but-inactive tools not present in the current config
    ///
    /// By default, `mise outdated` only shows tools that come from the current config.
    #[clap(long, verbatim_doc_comment, conflicts_with = "local")]
    pub inactive: bool,

    /// Only show outdated tools defined in local config files
    ///
    /// This will only show tools that are defined in project-local mise.toml and
    /// will skip tools defined in the global config (~/.config/mise/config.toml).
    #[clap(long, verbatim_doc_comment)]
    pub local: bool,

    /// Placeholder for future monorepo outdated checks; `mise outdated --monorepo` is not implemented yet.
    #[clap(long, verbatim_doc_comment)]
    pub monorepo: bool,

    /// Don't show table header
    #[clap(long)]
    pub no_header: bool,
}

impl Outdated {
    pub async fn run(mut self) -> Result<()> {
        if self.legacy_bump {
            deprecated_at!(
                "2026.8.5",
                "2027.8.5",
                "cli.outdated.bump-l",
                "`mise outdated -l` is deprecated. Use `mise outdated -b` or `mise outdated --bump` instead. After removal, `-l` will become shorthand for `--local`."
            );
            self.bump = true;
        }
        if self.monorepo {
            unimplemented!("mise outdated --monorepo is not implemented yet");
        }
        let config = Config::get().await?;
        let scope = if self.local {
            ConfigScope::LocalOnly
        } else {
            ConfigScope::All
        };
        let mut ts = ToolsetBuilder::new()
            .with_args(&self.tool)
            .with_scope(scope)
            .build(&config)
            .await?;
        let tool_set = self
            .tool
            .iter()
            .map(|t| t.ba.clone())
            .collect::<HashSet<_>>();
        ts.versions
            .retain(|_, tvl| tool_set.is_empty() || tool_set.contains(&tvl.backend));
        let outdated = ts
            .list_outdated_versions(
                &config,
                self.bump,
                &ResolveOptions {
                    inactive: self.inactive,
                    ..Default::default()
                },
            )
            .await;
        let bump_available = if !self.json && !self.bump && outdated.is_empty() {
            ts.list_outdated_versions(
                &config,
                true,
                &ResolveOptions {
                    inactive: self.inactive,
                    ..Default::default()
                },
            )
            .await
            .iter()
            .any(|o| o.bump.is_some())
        } else {
            false
        };
        self.display(outdated, bump_available)?;
        Ok(())
    }

    fn display(&self, outdated: Vec<OutdatedInfo>, bump_available: bool) -> Result<()> {
        match self.json {
            true => self.display_json(outdated)?,
            false => self.display_table(outdated, bump_available)?,
        }
        Ok(())
    }

    fn display_table(&self, outdated: Vec<OutdatedInfo>, bump_available: bool) -> Result<()> {
        if outdated.is_empty() {
            info!("All tools are up to date");
            if bump_available {
                info!(
                    "Newer versions are available outside the configured version ranges. Use `mise outdated --bump` to view them."
                );
            }
            return Ok(());
        }
        let mut table = tabled::Table::new(outdated);
        if !self.bump {
            table.with(Remove::column(ByColumnName::new("bump")));
        }
        table::default_style(&mut table, self.no_header);
        miseprintln!("{table}");
        Ok(())
    }

    fn display_json(&self, outdated: Vec<OutdatedInfo>) -> Result<()> {
        let mut map = IndexMap::new();
        for o in outdated {
            map.insert(o.name.to_string(), o);
        }
        miseprintln!("{}", serde_json::to_string_pretty(&map)?);
        Ok(())
    }
}

static AFTER_LONG_HELP: &str = color_print::cstr!(
    r#"<bold><underline>Deprecation:</underline></bold>

The `-l` shorthand for `--bump` is deprecated and will be removed in mise 2027.8.5.
After removal, `-l` will become shorthand for `--local`. Use `-b` or `--bump` instead.

<bold><underline>Examples:</underline></bold>

    $ <bold>mise outdated</bold>
    Plugin  Requested  Current  Latest
    python  3.11       3.11.0   3.11.1
    node    20         20.0.0   20.1.0

    $ <bold>mise outdated node</bold>
    Plugin  Requested  Current  Latest
    node    20         20.0.0   20.1.0

    $ <bold>mise outdated --json</bold>
    {"python": {"requested": "3.11", "current": "3.11.0", "latest": "3.11.1"}, ...}

    $ <bold>mise outdated --local</bold>
    Plugin  Requested  Current  Latest
    node    20         20.0.0   20.1.0
"#
);