feat: add new commands for pixi project {version|channel|platform|description}

src/cli/add.rs

@@ -360,7 +360,7 @@ async fn update_environment(
             crate::environment::sanity_check_project(project)?;
 
             // Get the currently installed packages
-            let prefix = Prefix::new(project.root().join(".pixi/env"))?;
+            let prefix = Prefix::new(project.environment_dir())?;
             let installed_packages = prefix.find_installed_packages(None).await?;
 
             // Update the prefix

src/cli/project/channel/add.rs

@@ -7,7 +7,6 @@ use itertools::Itertools;
 use miette::IntoDiagnostic;
 use rattler_conda_types::{Channel, ChannelConfig, Platform};
 
-/// Adds a channel to the project file and updates the lockfile.
 #[derive(Parser, Debug, Default)]
 pub struct Args {
     /// The channel name or URL
@@ -59,7 +58,7 @@ pub async fn execute(mut project: Project, args: Args) -> miette::Result<()> {
     // Update the installation if needed
     if !args.no_install {
         // Get the currently installed packages
-        let prefix = Prefix::new(project.root().join(".pixi/env"))?;
+        let prefix = Prefix::new(project.environment_dir())?;
         let installed_packages = prefix.find_installed_packages(None).await?;
 
         // Update the prefix

src/cli/project/channel/list.rs

@@ -0,0 +1,27 @@
+use crate::Project;
+use clap::Parser;
+
+#[derive(Parser, Debug, Default)]
+pub struct Args {
+    /// Whether to display the channel's names or urls
+    #[clap(long)]
+    pub urls: bool,
+}
+
+pub async fn execute(project: Project, args: Args) -> miette::Result<()> {
+    project.channels().iter().for_each(|channel| {
+        if args.urls {
+            // Print the channel's url
+            println!("{}", channel.base_url());
+        } else {
+            // Print the channel's name and fallback to the url if it doesn't have one
+            let name = channel
+                .name
+                .as_deref()
+                .unwrap_or(channel.base_url().as_str());
+            println!("{}", name);
+        }
+    });
+
+    Ok(())
+}

src/cli/project/channel/mod.rs

@@ -1,4 +1,6 @@
 pub mod add;
+pub mod list;
+pub mod remove;
 
 use crate::Project;
 use clap::Parser;
@@ -18,13 +20,20 @@ pub struct Args {
 
 #[derive(Parser, Debug)]
 pub enum Command {
+    /// Adds a channel to the project file and updates the lockfile.
     Add(add::Args),
+    /// List the channels in the project file.
+    List(list::Args),
+    /// Remove channel(s) from the project file and updates the lockfile.
+    Remove(remove::Args),
 }
 
 pub async fn execute(args: Args) -> miette::Result<()> {
     let project = Project::load_or_else_discover(args.manifest_path.as_deref())?;
 
     match args.command {
         Command::Add(args) => add::execute(project, args).await,
+        Command::List(args) => list::execute(project, args).await,
+        Command::Remove(args) => remove::execute(project, args).await,
     }
 }

src/cli/project/channel/remove.rs

@@ -0,0 +1,86 @@
+use crate::environment::update_prefix;
+use crate::lock_file::{load_lock_file, update_lock_file};
+use crate::prefix::Prefix;
+use crate::Project;
+use clap::Parser;
+use itertools::Itertools;
+use miette::IntoDiagnostic;
+use rattler_conda_types::{Channel, ChannelConfig, Platform};
+
+#[derive(Parser, Debug, Default)]
+pub struct Args {
+    /// The channel name(s) or URL
+    #[clap(required = true, num_args=1..)]
+    pub channel: Vec<String>,
+
+    /// Don't update the environment, only remove the channel(s) from the lock-file.
+    #[clap(long)]
+    pub no_install: bool,
+}
+
+pub async fn execute(mut project: Project, args: Args) -> miette::Result<()> {
+    // Determine which channels to remove
+    let channel_config = ChannelConfig::default();
+    let channels = args
+        .channel
+        .into_iter()
+        .map(|channel_str| {
+            Channel::from_str(&channel_str, &channel_config).map(|channel| (channel_str, channel))
+        })
+        .collect::<Result<Vec<_>, _>>()
+        .into_diagnostic()?;
+
+    let channels_to_remove = channels
+        .into_iter()
+        .filter(|(_name, channel)| project.channels().contains(channel))
+        .collect_vec();
+
+    if channels_to_remove.is_empty() {
+        eprintln!(
+            "{}The channel(s) are not present.",
+            console::style(console::Emoji("✔ ", "")).green(),
+        );
+        return Ok(());
+    }
+
+    // Load the existing lock-file
+    let lock_file = load_lock_file(&project).await?;
+
+    // Remove the channels from the manifest
+    project
+        .manifest
+        .remove_channels(channels_to_remove.iter().map(|(name, _channel)| name))?;
+
+    // Try to update the lock-file without the removed channels
+    let lock_file = update_lock_file(&project, lock_file, None).await?;
+    project.save()?;
+
+    // Update the installation if needed
+    if !args.no_install {
+        // Get the currently installed packages
+        let prefix = Prefix::new(project.environment_dir())?;
+        let installed_packages = prefix.find_installed_packages(None).await?;
+
+        // Update the prefix
+        update_prefix(
+            project.pypi_package_db()?,
+            &prefix,
+            installed_packages,
+            &lock_file,
+            Platform::current(),
+        )
+        .await?;
+    }
+
+    // Report back to the user
+    for (name, channel) in channels_to_remove {
+        eprintln!(
+            "{}Removed {} ({})",
+            console::style(console::Emoji("✔ ", "")).green(),
+            name,
+            channel.base_url()
+        );
+    }
+
+    Ok(())
+}

src/cli/project/description/get.rs

@@ -0,0 +1,9 @@
+use crate::Project;
+
+pub async fn execute(project: Project) -> miette::Result<()> {
+    // Print the description if it exists
+    if let Some(description) = project.description() {
+        println!("{}", description);
+    }
+    Ok(())
+}

src/cli/project/description/mod.rs

@@ -0,0 +1,37 @@
+pub mod get;
+pub mod set;
+
+use crate::Project;
+use clap::Parser;
+use std::path::PathBuf;
+
+/// Commands to manage project description.
+#[derive(Parser, Debug)]
+pub struct Args {
+    /// The path to 'pixi.toml'
+    #[clap(long, global = true)]
+    pub manifest_path: Option<PathBuf>,
+
+    /// The subcommand to execute
+    #[clap(subcommand)]
+    pub command: Command,
+}
+
+#[derive(Parser, Debug)]
+pub enum Command {
+    /// Get the project description.
+    Get,
+    /// Set the project description.
+    Set(set::Args),
+}
+
+pub async fn execute(args: Args) -> miette::Result<()> {
+    let project = Project::load_or_else_discover(args.manifest_path.as_deref())?;
+
+    match args.command {
+        Command::Get => get::execute(project).await?,
+        Command::Set(args) => set::execute(project, args).await?,
+    }
+
+    Ok(())
+}

src/cli/project/description/set.rs

@@ -0,0 +1,32 @@
+use crate::Project;
+use clap::Parser;
+
+#[derive(Parser, Debug, Default)]
+pub struct Args {
+    /// The project description
+    #[clap(required = true, num_args = 1)]
+    pub description: String,
+}
+
+pub async fn execute(mut project: Project, args: Args) -> miette::Result<()> {
+    // Set the description
+    project.manifest.set_description(&args.description)?;
+
+    // Save the manifest on disk
+    project.save()?;
+
+    // Report back to the user
+    eprintln!(
+        "{}Updated project description to '{}'.",
+        console::style(console::Emoji("✔ ", "")).green(),
+        project
+            .manifest
+            .parsed
+            .project
+            .description
+            .as_ref()
+            .unwrap()
+    );
+
+    Ok(())
+}

src/cli/project/mod.rs

@@ -2,10 +2,16 @@ use clap::Parser;
 use std::path::PathBuf;
 
 pub mod channel;
+pub mod description;
+pub mod platform;
+pub mod version;
 
 #[derive(Debug, Parser)]
 pub enum Command {
     Channel(channel::Args),
+    Description(description::Args),
+    Platform(platform::Args),
+    Version(version::Args),
 }
 
 /// Modify the project configuration file through the command line.
@@ -21,6 +27,9 @@ pub struct Args {
 pub async fn execute(cmd: Args) -> miette::Result<()> {
     match cmd.command {
         Command::Channel(args) => channel::execute(args).await?,
+        Command::Description(args) => description::execute(args).await?,
+        Command::Platform(args) => platform::execute(args).await?,
+        Command::Version(args) => version::execute(args).await?,
     };
     Ok(())
 }

src/cli/project/platform/add.rs

@@ -0,0 +1,82 @@
+use std::str::FromStr;
+
+use crate::environment::update_prefix;
+use crate::lock_file::{load_lock_file, update_lock_file};
+use crate::prefix::Prefix;
+use crate::Project;
+use clap::Parser;
+use itertools::Itertools;
+use miette::IntoDiagnostic;
+use rattler_conda_types::Platform;
+
+#[derive(Parser, Debug, Default)]
+pub struct Args {
+    /// The platform name(s) to add.
+    #[clap(required = true, num_args=1..)]
+    pub platform: Vec<String>,
+
+    /// Don't update the environment, only add changed packages to the lock-file.
+    #[clap(long)]
+    pub no_install: bool,
+}
+
+pub async fn execute(mut project: Project, args: Args) -> miette::Result<()> {
+    // Determine which platforms are missing
+    let platforms = args
+        .platform
+        .into_iter()
+        .map(|platform_str| Platform::from_str(&platform_str))
+        .collect::<Result<Vec<_>, _>>()
+        .into_diagnostic()?;
+
+    let missing_platforms = platforms
+        .into_iter()
+        .filter(|x| !project.platforms().contains(x))
+        .collect_vec();
+
+    if missing_platforms.is_empty() {
+        eprintln!(
+            "{}All platform(s) have already been added.",
+            console::style(console::Emoji("✔ ", "")).green(),
+        );
+        return Ok(());
+    }
+
+    // Load the existing lock-file
+    let lock_file = load_lock_file(&project).await?;
+
+    // Add the platforms to the lock-file
+    project.manifest.add_platforms(missing_platforms.iter())?;
+
+    // Try to update the lock-file with the new channels
+    let lock_file = update_lock_file(&project, lock_file, None).await?;
+    project.save()?;
+
+    // Update the installation if needed
+    if !args.no_install {
+        // Get the currently installed packages
+        let prefix = Prefix::new(project.environment_dir())?;
+        let installed_packages = prefix.find_installed_packages(None).await?;
+
+        // Update the prefix
+        update_prefix(
+            project.pypi_package_db()?,
+            &prefix,
+            installed_packages,
+            &lock_file,
+            Platform::current(),
+        )
+        .await?;
+    }
+
+    // Report back to the user
+    for platform in missing_platforms {
+        eprintln!(
+            "{}Added {}",
+            console::style(console::Emoji("✔ ", "")).green(),
+            platform
+        );
+    }
+
+    Ok(())
+}

src/cli/project/platform/list.rs

@@ -0,0 +1,9 @@
+use crate::Project;
+
+pub async fn execute(project: Project) -> miette::Result<()> {
+    project.platforms().iter().for_each(|platform| {
+        println!("{}", platform.as_str());
+    });
+
+    Ok(())
+}