stout 0.2.0

A fast, Rust-based Homebrew-compatible package manager
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

//! Outdated command - list packages with available updates

use anyhow::{Context, Result};
use stout_index::Database;
use stout_state::{InstalledPackages, Paths};
use clap::Args as ClapArgs;
use console::style;

#[derive(ClapArgs)]
pub struct Args {
    /// Only check specific formulas
    pub formulas: Vec<String>,

    /// Show detailed version information
    #[arg(long, short = 'v')]
    pub verbose: bool,

    /// Output in JSON format
    #[arg(long)]
    pub json: bool,

    /// Only list outdated formulas (not casks)
    #[arg(long)]
    pub formula: bool,

    /// Only list outdated casks
    #[arg(long)]
    pub cask: bool,

    /// List packages that would be upgraded with `stout upgrade`
    #[arg(long)]
    pub greedy: bool,
}

/// Information about an outdated package
#[derive(Debug, serde::Serialize)]
struct OutdatedPackage {
    name: String,
    installed_version: String,
    current_version: String,
    pinned: bool,
}

pub async fn run(args: Args) -> Result<()> {
    let paths = Paths::default();
    let installed = InstalledPackages::load(&paths)?;

    let db = Database::open(paths.index_db())
        .context("Failed to open index. Run 'stout update' first.")?;

    if !db.is_initialized()? {
        eprintln!(
            "{} Index not initialized. Run 'stout update' first.",
            style("error:").red().bold()
        );
        std::process::exit(1);
    }

    let mut outdated: Vec<OutdatedPackage> = Vec::new();

    // Get list of packages to check
    let packages_to_check: Vec<String> = if args.formulas.is_empty() {
        installed.names().map(|s| s.to_string()).collect()
    } else {
        args.formulas.clone()
    };

    for name in packages_to_check {
        let pkg = match installed.get(&name) {
            Some(p) => p,
            None => continue,
        };

        // Look up current version in index
        if let Ok(Some(info)) = db.get_formula(&name) {
            if info.version != pkg.version {
                outdated.push(OutdatedPackage {
                    name: name.clone(),
                    installed_version: pkg.version.clone(),
                    current_version: info.version,
                    pinned: pkg.pinned,
                });
            }
        }
    }

    // Filter pinned packages unless --greedy
    if !args.greedy {
        outdated.retain(|p| !p.pinned);
    }

    if args.json {
        // JSON output
        let json = serde_json::to_string_pretty(&outdated)?;
        println!("{}", json);
    } else if outdated.is_empty() {
        // No outdated packages
        if args.formulas.is_empty() {
            println!("{}", style("All packages are up to date.").green());
        } else {
            println!("{}", style("Specified packages are up to date.").green());
        }
    } else {
        // Human-readable output
        for pkg in &outdated {
            if args.verbose {
                println!(
                    "{} {} -> {}{}",
                    style(&pkg.name).cyan(),
                    style(&pkg.installed_version).yellow(),
                    style(&pkg.current_version).green(),
                    if pkg.pinned {
                        style(" [pinned]").dim().to_string()
                    } else {
                        String::new()
                    }
                );
            } else {
                print!("{}", pkg.name);
                if pkg.pinned {
                    print!(" {}", style("[pinned]").dim());
                }
                println!();
            }
        }

        println!(
            "\n{} {} outdated package{}",
            style("==>").blue().bold(),
            outdated.len(),
            if outdated.len() == 1 { "" } else { "s" }
        );
    }

    Ok(())
}