feat(ui/ux): clean up install command cli prints for bottles and casks

Signed-off-by: Alexander Knott <alexander.knott@r-kom.de>

Author: alexanderknott

spm-cli/src/cli/install/cask.rs

@@ -16,7 +16,6 @@ fn join_to_err(e: JoinError) -> SpmError {
 }
 
 pub async fn run_cask_install(token: &str, cache: Arc<Cache>, cfg: &Config) -> Result<()> {
-    info!("Processing cask: {}", token.cyan());
     let cask: Cask = match api::get_cask(token).await {
         Ok(c) => c,
         Err(e) => {
@@ -54,7 +53,7 @@ pub async fn run_cask_install(token: &str, cache: Arc<Cache>, cfg: &Config) -> R
         }
     }
 
-    info!("Downloading artifact for {}", token);
+    info!("Downloading {}", token.cyan());
     let dl_path: PathBuf = match build::cask::download_cask(&cask, cache.as_ref()).await {
         Ok(p) => p,
         Err(e) => {
@@ -63,7 +62,7 @@ pub async fn run_cask_install(token: &str, cache: Arc<Cache>, cfg: &Config) -> R
         }
     };
 
-    debug!("Installing cask {} from {}...", token, dl_path.display());
+    info!("Processing {}", token.cyan());
     tokio::task::spawn_blocking({
         let cask_clone = cask.clone();
         let dl_clone = dl_path.clone();
@@ -73,6 +72,5 @@ pub async fn run_cask_install(token: &str, cache: Arc<Cache>, cfg: &Config) -> R
     .await
     .map_err(join_to_err)??;
 
-    debug!("Cask {} installation task completed successfully", token);
     Ok(())
 }

spm-cli/src/cli/install/formula/bottle.rs

@@ -25,14 +25,12 @@ pub async fn run_bottle_install(
     let name = formula.name();
     let final_opt_path = get_formula_opt_path(formula, &cfg);
 
-    info!("Processing bottle for: {}...", name.cyan());
-
     // Check if already installed (defensive check)
     let keg_registry = spm_core::keg::KegRegistry::new(cfg.clone());
     if let Some(keg) = keg_registry.get_installed_keg(name)? {
         if keg.version == *formula.version() && keg.revision == formula.revision {
             info!(
-                "Formula {} v{} is already installed.",
+                "{} v{} is already installed.",
                 name,
                 formula.version_str_full()
             );
@@ -48,12 +46,12 @@ pub async fn run_bottle_install(
     }
 
     // Download
-    info!("Downloading bottle for {}...", name);
+    info!("Downloading {}", name.cyan());
     let bottle_path =
         build::formula::bottle::download_bottle(formula, &cfg, client.as_ref()).await?;
 
     // Install (blocking)
-    info!("Pouring bottle for {}...", name);
+    info!("Processing {}", name.cyan());
     let install_dir: PathBuf = tokio::task::spawn_blocking({
         let formula_clone = formula.clone();
         let cfg_clone = cfg.clone();
@@ -65,10 +63,7 @@ pub async fn run_bottle_install(
     .await
     .map_err(join_to_err)??;
 
-    // Link
-    info!("Linking artifacts for {}...", name);
     build::formula::link::link_formula_artifacts(formula, &install_dir, &cfg)?;
 
-    info!("Poured and linked {}", name.green());
     Ok(final_opt_path)
 }

spm-cli/src/cli/install/formula/source.rs

@@ -15,7 +15,7 @@ pub async fn run_source_install(info: FormulaInstallInfo, cfg: Config) -> Result
     let resolved_graph = info.resolved_graph;
     let final_opt_path = get_formula_opt_path(formula, &cfg);
 
-    info!("Processing source build for: {}...", name.cyan());
+    info!("Processing source build for: {}", name.cyan());
 
     // Check if already installed (defensive check)
     let keg_registry = spm_core::keg::KegRegistry::new(cfg.clone());
@@ -37,10 +37,10 @@ pub async fn run_source_install(info: FormulaInstallInfo, cfg: Config) -> Result
         }
     }
 
-    info!("Downloading source for {}...", name);
+    info!("Downloading source for {}", name);
     let source_path = build::formula::source::download_source(formula, &cfg).await?;
 
-    info!("Compiling {}...", name);
+    info!("Compiling {}", name);
     let build_dep_paths = resolved_graph.build_dependency_opt_paths.clone();
     let runtime_dep_paths = resolved_graph.runtime_dependency_opt_paths.clone();
     let all_dep_paths = [build_dep_paths, runtime_dep_paths].concat();
@@ -53,9 +53,8 @@ pub async fn run_source_install(info: FormulaInstallInfo, cfg: Config) -> Result
     )
     .await?; // Await the result directly
 
-    info!("Linking artifacts for {}...", name);
+    info!("Linking artifacts for {}", name);
     build::formula::link::link_formula_artifacts(formula, &install_dir, &cfg)?;
 
-    info!("Built and linked {}", name.green());
     Ok(final_opt_path)
 }

spm-cli/src/cli/install/mod.rs

@@ -125,8 +125,8 @@ impl Install {
             plan_input.formulae_names.iter().cloned().collect();
 
         if !formula_list_to_resolve.is_empty() {
-            info!(
-                "Resolving dependencies for {} potential formula(e)...",
+            debug!(
+                "Resolving dependencies for {} potential formula(e)",
                 formula_list_to_resolve.len()
             );
             let formulary = Formulary::new(cfg.clone());
@@ -188,7 +188,7 @@ impl Install {
                 }
             }
         } else {
-            info!("No formulae identified for resolution.");
+            debug!("No formulae identified for resolution.");
         }
 
         let mut tasks_to_run: HashMap<String, TaskType> = HashMap::new();
@@ -234,7 +234,7 @@ impl Install {
                     debug!("Skipping adding cask task for '{}' due to previous error or unknown status.", name);
                 }
             } else if tasks_to_run.contains_key(name) && !self.cask_only {
-                warn!("Target '{}' identified as both Formula and Cask. Prioritizing Formula install.", name);
+                info!("Target '{}' identified as both Formula and Cask. Prioritizing Formula install.", name);
             }
         }
 
@@ -255,8 +255,7 @@ impl Install {
         }
 
         info!(
-            "Planning to install {} package(s): {:?}",
-            task_list.len(),
+            "Target with dependencies added: {:?}",
             task_list.iter().map(|(n, _)| n).collect::<Vec<_>>()
         );
 
@@ -269,8 +268,6 @@ impl Install {
 
         let mut task_iter = task_list.into_iter();
 
-        info!("{}", "Starting installation process...".blue().bold());
-
         while pending_tasks > 0 {
             while let Ok(permit) = sem.clone().try_acquire_owned() {
                 if let Some((task_name, task)) = task_iter.next() {
@@ -318,7 +315,7 @@ impl Install {
                         debug!("Task completed for '{}': {:?}", name, result.is_ok());
                         if let Err(SpmError::InstallError(ref msg)) = result {
                             if msg.contains("already installed") {
-                                info!("☑️ Skipping already installed cask: {}", name.yellow());
+                                info!("Skipping installed cask: {}", name.yellow());
                                 task_results.insert(name, Ok(PathBuf::new()));
                             } else {
                                 task_results.insert(name, result);
@@ -349,17 +346,16 @@ impl Install {
             }
         }
 
-        info!("Installation process finished.");
         let mut final_success = true;
 
         for (name, result) in task_results {
             match result {
                 Ok(path) => {
                     if path.as_os_str().is_empty() {
-                        info!("Successfully installed/skipped cask: {}", name.green());
+                        info!("Successfully installed: {}", name.green());
                     } else {
                         info!(
-                            "Successfully installed formula: {} ({})",
+                            "Successfully installed: {} ({})",
                             name.green(),
                             path.display()
                         );
@@ -404,16 +400,16 @@ impl Install {
         let targets_to_check: HashSet<String> = self.names.iter().cloned().collect();
 
         if self.formula_only {
-            info!("--formula-only specified: Treating all targets as formulae.");
+            info!("--formula-only: Treating all targets as formulae");
             plan_input.formulae_names = targets_to_check;
             return Ok(plan_input);
         }
         if self.cask_only {
-            info!("--cask-only specified: Treating all targets as casks.");
+            info!("--cask-only: Treating all targets as casks.");
             plan_input.cask_names = targets_to_check;
             // Proceed to fetch cask deps below
         } else {
-            info!("Classifying initial targets: {:?}", self.names);
+            info!("Initial installation target(s): {:?}", self.names);
 
             // Load formula and cask data concurrently from cache/API
             let formula_data_future =