feat: Improve Sharded Repodata Progress Message (#4225)

Signed-off-by: Julien Jerphanion <git@jjerphan.xyz>

Author: jjerphan

libmamba/include/mamba/core/output.hpp

@@ -128,9 +128,10 @@ namespace mamba
         /**
          * Check if status messages can be reported to stdout.
          *
-         * Returns true if Console is available and JSON output is not enabled.
-         * Use this before printing status messages to ensure they don't
-         * interfere with JSON output.
+         * Returns true when Console is available, `libmamba` is running from an
+         * end-user executable (`mamba`/`micromamba`), and JSON output is disabled.
+         * Use this before printing status messages to avoid leaking CLI-only
+         * status lines to third-party `libmamba` integrations.
          */
         [[nodiscard]] static bool can_report_status();
         static ConsoleStream stream();
@@ -146,6 +147,7 @@ namespace mamba
         static std::string hide_secrets(std::string_view str);
 
         void print(std::string_view str, bool force_print = false);
+        void print_in_place(std::string_view str, bool finalize = false, bool force_print = false);
         void json_write(const nlohmann::json& j);
         void json_append(const std::string& value);
         void json_append(const nlohmann::json& j);

libmamba/src/api/utils.cpp

@@ -5,6 +5,7 @@
 // The full license is in the file LICENSE, distributed with this software.
 
 #include <cctype>
+#include <chrono>
 #include <fstream>
 #include <unordered_set>
 
@@ -46,6 +47,12 @@ namespace mamba
 {
     namespace
     {
+        auto done_with_duration(std::chrono::steady_clock::duration elapsed) -> std::string
+        {
+            const double seconds = std::chrono::duration<double>(elapsed).count();
+            return fmt::format("✔ Done ({:.1f} sec)", seconds);
+        }
+
         tl::expected<command_args, std::runtime_error> get_pkg_mgr_install_command(
             const std::string& name,
             const std::string& target_prefix,
@@ -458,10 +465,11 @@ namespace mamba
     {
         if (Console::can_report_status())
         {
-            Console::instance().print(
+            Console::instance().print_in_place(
                 fmt::format("{:<85} {:>20}", "Resolving Environment", "⧖ Starting")
             );
         }
+        const auto started_at = std::chrono::steady_clock::now();
         auto outcome = solver::libsolv::Solver()
                            .solve(
                                db,
@@ -473,7 +481,14 @@ namespace mamba
                            .value();
         if (Console::can_report_status())
         {
-            Console::instance().print(fmt::format("{:<85} {:>20}", "Resolving Environment", "✔ Done"));
+            Console::instance().print_in_place(
+                fmt::format(
+                    "{:<85} {:>20}",
+                    "Resolving Environment",
+                    done_with_duration(std::chrono::steady_clock::now() - started_at)
+                ),
+                true
+            );
         }
         return outcome;
     }

libmamba/src/core/output.cpp

@@ -8,6 +8,7 @@
 #include <cstdlib>
 #include <iostream>
 #include <map>
+#include <optional>
 #include <string>
 
 #include <fmt/color.h>
@@ -23,6 +24,7 @@
 #include "mamba/core/tasksync.hpp"
 #include "mamba/core/thread_utils.hpp"
 #include "mamba/core/util.hpp"
+#include "mamba/core/util_os.hpp"
 #include "mamba/specs/conda_url.hpp"
 #include "mamba/util/string.hpp"
 #include "mamba/util/synchronized_value.hpp"
@@ -301,6 +303,7 @@ namespace mamba
         {
             std::unique_ptr<ProgressBarManager> progress_bar_manager;
             ConsoleBuffer buffer;
+            std::optional<std::size_t> active_in_place_width;
         };
 
         util::synchronized_value<Data> m_synched_data;
@@ -346,7 +349,8 @@ namespace mamba
 
     bool Console::can_report_status()
     {
-        return is_available() && !instance().context().output_params.json;
+        const auto& ctx = instance().context();
+        return is_available() && ctx.command_params.is_mamba_exe && !ctx.output_params.json;
     }
 
     void Console::cancel_json_print()
@@ -371,11 +375,54 @@ namespace mamba
             }
             else
             {
+                if (synched_data->active_in_place_width.has_value())
+                {
+                    std::cout << '\n';
+                    synched_data->active_in_place_width.reset();
+                }
                 std::cout << hide_secrets(str) << std::endl;
             }
         }
     }
 
+    void Console::print_in_place(std::string_view str, bool finalize, bool force_print)
+    {
+        if (force_print || !(context().output_params.quiet || context().output_params.json))
+        {
+            auto synched_data = p_data->m_synched_data.synchronize();
+
+            if (synched_data->progress_bar_manager && synched_data->progress_bar_manager->started())
+            {
+                synched_data->buffer.push_back(hide_secrets(str));
+                return;
+            }
+
+            const std::string sanitized = hide_secrets(str);
+            const bool can_update_in_place = is_atty(std::cout);
+            if (!can_update_in_place)
+            {
+                std::cout << sanitized << std::endl;
+                return;
+            }
+
+            const std::size_t previous_width = synched_data->active_in_place_width.value_or(0);
+            const std::size_t next_width = sanitized.size();
+            const std::size_t pad = previous_width > next_width ? previous_width - next_width : 0;
+            std::cout << '\r' << sanitized << std::string(pad, ' ');
+
+            if (finalize)
+            {
+                std::cout << '\n';
+                synched_data->active_in_place_width.reset();
+            }
+            else
+            {
+                std::cout << std::flush;
+                synched_data->active_in_place_width = next_width;
+            }
+        }
+    }
+
     void Console::print_buffer(std::ostream& ostream)
     {
         auto& data = instance().p_data;

libmamba/src/core/shard_index_loader.cpp

@@ -34,6 +34,12 @@
 
 namespace
 {
+    auto done_with_duration(std::chrono::steady_clock::duration elapsed) -> std::string
+    {
+        const double seconds = std::chrono::duration<double>(elapsed).count();
+        return fmt::format("✔ Done ({:.1f} sec)", seconds);
+    }
+
     /**
      * Parse the "shards" map from msgpack (package name -> hash bytes).
      */
@@ -611,8 +617,9 @@ namespace mamba
                 label = label.substr(0, 82) + "...";
             }
 
-            Console::instance().print(fmt::format("{:<85} {:>20}", label, "⧖ Starting"));
+            Console::instance().print_in_place(fmt::format("{:<85} {:>20}", label, "⧖ Starting"));
         }
+        const auto started_at = std::chrono::steady_clock::now();
 
         // Build download request
         auto request_opt = build_shard_index_request(
@@ -686,7 +693,14 @@ namespace mamba
                 {
                     done_label = done_label.substr(0, 82) + "...";
                 }
-                Console::instance().print(fmt::format("{:<85} {:>20}", done_label, "✔ Done"));
+                Console::instance().print_in_place(
+                    fmt::format(
+                        "{:<85} {:>20}",
+                        done_label,
+                        done_with_duration(std::chrono::steady_clock::now() - started_at)
+                    ),
+                    true
+                );
             }
             return std::optional<ShardsIndexDict>(std::move(index_result.value()));
         }

libmamba/src/core/shard_traversal.cpp

@@ -5,6 +5,7 @@
 // The full license is in the file LICENSE, distributed with this software.
 
 #include <algorithm>
+#include <chrono>
 #include <set>
 #include <vector>
 
@@ -43,6 +44,12 @@ namespace mamba
 
     namespace
     {
+        auto done_with_duration(std::chrono::steady_clock::duration elapsed) -> std::string
+        {
+            const double seconds = std::chrono::duration<double>(elapsed).count();
+            return fmt::format("✔ Done ({:.1f} sec)", seconds);
+        }
+
         void add_names_from_specs(const std::vector<std::string>& specs, std::set<std::string>& names)
         {
             for (const auto& spec : specs)
@@ -111,10 +118,11 @@ namespace mamba
         }
         if (Console::can_report_status())
         {
-            Console::instance().print(
+            Console::instance().print_in_place(
                 fmt::format("{:<85} {:>20}", "Fetching and Parsing Packages' Shards", "⧖ Starting")
             );
         }
+        const auto started_at = std::chrono::steady_clock::now();
         if (strategy == "bfs")
         {
             reachable_bfs(root_packages, root_shards);
@@ -125,8 +133,13 @@ namespace mamba
         }
         if (Console::can_report_status())
         {
-            Console::instance().print(
-                fmt::format("{:<85} {:>20}", "Fetching and Parsing Packages' Shards", "✔ Done")
+            Console::instance().print_in_place(
+                fmt::format(
+                    "{:<85} {:>20}",
+                    "Fetching and Parsing Packages' Shards",
+                    done_with_duration(std::chrono::steady_clock::now() - started_at)
+                ),
+                true
             );
         }
     }