wovensnake 0.3.6

A high-performance Python package manager built with Rust.
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

#![warn(clippy::all, clippy::pedantic, clippy::nursery, rust_2018_idioms)]
#![allow(
    clippy::must_use_candidate,
    clippy::module_name_repetitions,
    clippy::missing_errors_doc,
    clippy::too_many_arguments,
    clippy::missing_panics_doc,
    clippy::uninlined_format_args
)]

use clap::{Parser, Subcommand};
use wovensnake::cli;
use wovensnake::cli::ux;

#[derive(Parser)]
#[command(name = "woven", version)]
#[command(about = "A Python package manager built with Rust", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Initialize a new `WovenSnake` project
    Init {
        /// Skip interactive prompts and use defaults
        #[arg(short, long)]
        yes: bool,
    },
    /// Add a new package to the project (alias: use `woven install <pkg>`)
    #[command(hide = true)]
    Add {
        /// Name of the package to add
        name: String,
        /// Optional version of the package
        version: Option<String>,
    },
    /// Install dependencies, or add and install specific packages
    Install {
        /// Packages to add (e.g. requests, flask==3.0.0). Installs all if omitted.
        #[arg(trailing_var_arg = true)]
        packages: Vec<String>,
    },
    /// Update dependencies to their latest versions
    Update,
    /// Run a command within the virtual environment
    Run {
        #[arg(trailing_var_arg = true)]
        args: Vec<String>,
    },
    /// Remove a package
    Remove { name: String },
    /// List installed packages
    List,
    /// Clean project dependencies and virtual environment
    Clean {
        /// Also clear the global cache
        #[arg(long)]
        all: bool,
        /// Also clear managed Python versions
        #[arg(long)]
        python: bool,
    },
    /// Uninstall `WovenSnake` from this machine
    #[command(name = "self-uninstall")]
    SelfUninstall {
        /// Skip confirmation prompt
        #[arg(short, long)]
        yes: bool,
    },
}

#[tokio::main]
async fn main() {
    let cli = Cli::parse();

    match cli.command {
        Commands::Init { yes } => {
            if !yes {
                ux::print_welcome();
            }
            if let Err(e) = cli::init::execute(yes) {
                ux::print_error(format!("Failed to initialize project: {e}"));
            }
        }
        Commands::Add { name, version } => {
            if let Err(e) = cli::add::execute(&name, version).await {
                ux::print_error(format!("Failed to add package '{name}': {e}"));
            }
        }
        Commands::Install { packages } => {
            if packages.is_empty() {
                // woven install  →  install all from wovenpkg.json
                if let Err(e) = cli::install::execute(false).await {
                    ux::print_error(format!("Installation failed: {e}"));
                }
            } else {
                // woven install requests flask==3.0.0  →  add each package then install
                for pkg in &packages {
                    let (name, version) = pkg
                        .split_once("==")
                        .map_or_else(|| (pkg.clone(), None), |(n, v)| (n.to_string(), Some(v.to_string())));
                    if let Err(e) = cli::add::execute(&name, version).await {
                        ux::print_error(format!("Failed to add '{name}': {e}"));
                        break;
                    }
                }
            }
        }
        Commands::Update => {
            if let Err(e) = cli::update::execute().await {
                ux::print_error(format!("Update failed: {e}"));
            }
        }
        Commands::Run { args } => {
            if let Err(e) = cli::run::execute(&args) {
                ux::print_error(format!("Execution failed: {e}"));
                std::process::exit(1);
            }
        }
        Commands::Remove { name } => {
            if let Err(e) = cli::remove::execute(&name).await {
                ux::print_error(format!("Failed to remove package '{name}': {e}"));
            }
        }
        Commands::List => {
            if let Err(e) = cli::list::execute() {
                ux::print_error(format!("Failed to list packages: {e}"));
            }
        }
        Commands::Clean { all, python } => {
            if let Err(e) = cli::clean::execute(all, python) {
                ux::print_error(format!("Clean failed: {e}"));
            }
        }
        Commands::SelfUninstall { yes } => {
            if let Err(e) = cli::self_uninstall::execute(yes) {
                ux::print_error(format!("Uninstall failed: {e}"));
            }
        }
    }
}