std::string code; // e.g. "E0001" (optional)

std::string title;

std::filesystem::path path;

std::size_t line = 0;

std::size_t column = 0;

std::string sourceLine; // optional snippet

std::string spanMessage; // points at column

std::vector<std::string> notes;

std::vector<std::string> helps;

ProgressBar(std::string_view verb, std::string_view label);

~ProgressBar();

ProgressBar(const ProgressBar&) = delete;

ProgressBar& operator=(const ProgressBar&) = delete;

// Update progress; renders only once per ~50ms to avoid jitter.

void update(std::size_t percent);

// elapsed_sec, when > 0, drives a `~X.Y MB/s` average-rate suffix.

void update_bytes(std::size_t current_bytes, std::size_t total_bytes,

double elapsed_sec = 0.0);

// Connecting / pre-sizing phase: the total size isn't known yet (the

// downloader reports totalBytes==0 during DNS/TLS/redirect before the

// transfer's Content-Length is available, and some servers stream with no

// length at all). Renders a swept (indeterminate) bar plus a ticking

// `connecting… Ns` / `X.Y MB Ns` suffix so the line never freezes.

void update_indeterminate(std::size_t current_bytes,

double elapsed_sec = 0.0);

// Finish: replaces progress with final-state line.

void finish();

void finish_with(std::string_view final_message);

void render_line(std::size_t percent, const std::string& info_text);

void render_line_swept(std::size_t frame, const std::string& info_text);

std::string verb_;

std::string label_;

std::chrono::steady_clock::time_point lastDraw_;

bool finished_ = false;

std::string name;

std::size_t downloaded = 0;

std::size_t total = 0; // 0 = size not known yet (connecting)

bool started = false;

bool finished = false;

DownloadProgress() = default;

~DownloadProgress();

DownloadProgress(const DownloadProgress&) = delete;

DownloadProgress& operator=(const DownloadProgress&) = delete;

void update(std::span<const DownloadFile> files, double elapsed_sec);

void finish(); // finish the active bar if any (idempotent)

std::optional<ProgressBar> bar_;

std::string active_;

std::unordered_set<std::string> finished_;

std::filesystem::path project_root;

std::filesystem::path mcpp_home;

std::filesystem::path home;

if (auto* e = std::getenv("MCPP_NO_COLOR"); e && *e == '1') return false;

if (auto* e = std::getenv("NO_COLOR"); e && *e) return false;

return mcpp::platform::terminal::is_tty();

if (!g_color) return std::string(text);

std::string out;

out.reserve(code.size() + text.size() + kReset.size());

out.append(code).append(text).append(kReset);

return out;

constexpr std::size_t W = 12;

if (verb.size() >= W) return std::string(verb);

std::string s(W - verb.size(), ' ');

s.append(verb);

return s;

if (g_inited) return;

g_color = detect_color();

g_inited = true;

#if defined(_WIN32)

// Not on Windows, and not as a preference. The UCRT documents setvbuf's

// size as `2 <= size <= INT_MAX`, and a zero goes through the

// invalid-parameter handler, whose default action terminates the process:

// 0xC0000409, which git-bash reports as a bare exit 127. The freshly built

// mcpp.exe died on `--version` before printing anything.

//

// Passing a real size instead would buy nothing: MSVCRT has no line

// buffering at all — it accepts _IOLBF and treats it as _IOFBF. Windows

// gets the same guarantee from ui::flush(), which every stdout-writing

// function here calls, so the platform that cannot do this cheaply is also

// the one that does not need it: its 4096-byte block is the smallest of the

// three anyway, and `mcpp test` routes its result lines through ui::plain.

#else

std::setvbuf(stdout, nullptr, _IOLBF, 0);

#endif

if (g_quiet) return;

init();

auto v = verb_padded(verb);

if (g_color) {

std::println("{}{}{}{} {}",

kBold, kBrightGreen, v, kReset, message);

} else {

std::println("{} {}", v, message);

}

flush();

if (g_quiet) return;

init();

auto v = verb_padded(verb);

if (g_color) {

std::println("{}{}{}{} {}",

kBold, kBrightCyan, v, kReset, message);

} else {

std::println("{} {}", v, message);

}

flush();

std::string_view descriptor) {

if (g_quiet) return;

init();

auto v = verb_padded("Finished");

auto secs = static_cast<double>(elapsed.count()) / 1000.0;

// `[optimized]` used to be hardcoded here alongside a hardcoded "release"

// at the only call site, so every build — including `--dev` at -O0 -g —

// announced "Finished release [optimized]". The descriptor is now supplied

// by whoever actually resolved the profile knobs, and omitted by callers

// (the fast path) that never resolved them: no caller has to guess.

auto msg = descriptor.empty()

? std::format("{} in {:.2f}s", profile, secs)

: std::format("{} [{}] in {:.2f}s", profile, descriptor, secs);

if (g_color) {

std::println("{}{}{}{} {}",

kBold, kBrightGreen, v, kReset, msg);

} else {

std::println("{} {}", v, msg);

}

flush();

init();

if (g_color) {

std::println(stderr, "{}{}warning:{} {}", kBold, kYellow, kReset, message);

} else {

std::println(stderr, "warning: {}", message);

}

init();

if (g_color) {

std::println(stderr, "{}{}error:{} {}", kBold, kBrightRed, kReset, message);

} else {

std::println(stderr, "error: {}", message);

}

if (g_quiet) return;

std::println("{}", message);

flush();

init();

auto bold_red = [&](std::string_view s) {

return g_color ? std::format("{}{}{}{}", kBold, kBrightRed, s, kReset)

: std::string(s);

};

auto blue = [&](std::string_view s) {

return g_color ? std::format("{}{}{}{}", kBold, kBrightCyan, s, kReset)

: std::string(s);

};

std::string head = "error";

if (!d.code.empty()) head += "[" + d.code + "]";

head += ":";

std::println(stderr, "{} {}", bold_red(head), d.title);

if (!d.path.empty()) {

if (d.line)

std::println(stderr, " {} {}:{}{}",

blue("-->"), d.path.string(), d.line,

d.column ? std::format(":{}", d.column) : "");

else

std::println(stderr, " {} {}", blue("-->"), d.path.string());

}

if (!d.sourceLine.empty()) {

std::println(stderr, " {}", blue("|"));

std::println(stderr, " {} {} {}",

d.line ? std::format("{:>2}", d.line) : " ", blue("|"), d.sourceLine);

if (!d.spanMessage.empty()) {

std::string caret(d.column ? d.column - 1 : 0, ' ');

caret += "^";

std::println(stderr, " {} {} {}", blue("|"), caret, d.spanMessage);

}

}

if (!d.notes.empty() || !d.helps.empty()) {

std::println(stderr, " {}", blue("|"));

}

for (auto& n : d.notes) {

std::println(stderr, " {} {}: {}", blue("="), blue("note"), n);

}

for (auto& h : d.helps) {

std::println(stderr, " {} {}: {}", blue("="), blue("help"), h);

}

if (!d.code.empty()) {

std::println(stderr, "");

std::println(stderr, "For more information on this error: `mcpp --explain {}`",

d.code);

}

auto filled = (percent * width) / 100;

if (filled > width) filled = width;

std::string bar = "[";

for (std::size_t i = 0; i < filled; ++i) bar += "=";

if (filled < width) bar += ">";

for (std::size_t i = filled + 1; i < width; ++i) bar += " ";

bar += "]";

return bar;

if (b < 1024) return std::format("{} B", b);

if (b < 1024 * 1024) return std::format("{} KB", b / 1024);

if (b < 1024UL*1024*1024) return std::format("{:.1f} MB", static_cast<double>(b) / (1024.0*1024.0));

return std::format("{:.2f} GB", static_cast<double>(b) / (1024.0*1024.0*1024.0));

if (s.size() <= max) return s;

if (max == 0) return std::string{};

if (max == 1) { s.resize(1); return s; }

s.resize(max - 1);

s += "…"; // 3-byte UTF-8 char in a single visible column — harmless

return s;

if (width == 0) return "[]";

std::size_t block = std::min<std::size_t>(3, width);

std::size_t span = width - block; // cells the block can travel

std::size_t pos = 0;

if (span > 0) {

std::size_t period = span * 2;

std::size_t p = frame % period;

pos = (p <= span) ? p : (period - p); // ping-pong

}

std::string inner(width, ' ');

for (std::size_t i = 0; i < block && pos + i < width; ++i) inner[pos + i] = '=';

return "[" + inner + "]";

MakeBar&& makeBar, const std::string& info_text)

{

constexpr std::size_t kVerbWidth = 12;

constexpr std::size_t kBarMax = 20;

constexpr std::size_t kBarMin = 6;

auto cols = terminal_cols();

if (cols < 30) cols = 30; // pathological — give us a chance

auto budget = cols - 1; // leave one cell for cursor

auto fixed = kVerbWidth + 3 + 2 + info_text.size();

if (fixed >= budget) {

// Truly tiny terminal — drop the bar entirely.

auto labelBudget = budget > kVerbWidth + 1 + info_text.size() + 1

? budget - kVerbWidth - 1 - info_text.size() - 1

: 0;

auto lbl = trunc_visible(label, labelBudget);

if (g_color) {

std::print("\r\033[2K{}{}{}{} {} {}",

kBold, kBrightCyan, verb_padded(verb), kReset,

lbl, info_text);

} else {

std::print("\r\033[2K{} {} {}", verb_padded(verb), lbl, info_text);

}

std::fflush(stdout);

return;

}

auto contentBudget = budget - fixed; // barInner + visible-label-cols

std::size_t barW = std::min(kBarMax, contentBudget);

std::size_t labelMax = contentBudget - barW;

if (barW < kBarMin && labelMax > 0) {

auto steal = std::min(kBarMin - barW, labelMax);

barW += steal;

labelMax -= steal;

}

auto bar = makeBar(barW);

auto lbl = trunc_visible(label, labelMax);

if (g_color) {

std::print("\r\033[2K{}{}{}{} {} {} {}",

kBold, kBrightCyan, verb_padded(verb), kReset,

lbl, bar, info_text);

} else {

std::print("\r\033[2K{} {} {} {}",

verb_padded(verb), lbl, bar, info_text);

}

std::fflush(stdout);

{

init();

draw_status_line(verb_, label_,

[pct](std::size_t w) { return render_bar(pct, w); },

info_text);

{

init();

draw_status_line(verb_, label_,

[frame](std::size_t w) { return render_bar_swept(frame, w); },

info_text);

if (g_quiet || finished_) return;

auto now = std::chrono::steady_clock::now();

if (now - lastDraw_ < std::chrono::milliseconds(80) && percent < 100) return;

lastDraw_ = now;

render_line(percent, std::format("{}%", percent));

double elapsed_sec) {

if (g_quiet || finished_) return;

auto now = std::chrono::steady_clock::now();

auto pct = total ? (current * 100 / total) : 0;

if (pct > 100) pct = 100;

// Same throttle as update(): one render per ~80ms unless we hit 100%.

if (now - lastDraw_ < std::chrono::milliseconds(80) && pct < 100) return;

lastDraw_ = now;

auto info = std::format("{} / {}", fmt_bytes(current), fmt_bytes(total));

// Average rate since the download started. xlings only ships the

// cumulative `elapsedSec`, so this is "since-start" rather than

// a sliding-window instantaneous speed — accurate enough for UX.

if (elapsed_sec > 0.5 && current > 0) {

auto rate = static_cast<std::size_t>(

static_cast<double>(current) / elapsed_sec);

info += std::format(" {}/s", fmt_bytes(rate));

}

render_line(pct, info);

double elapsed_sec) {

if (g_quiet || finished_) return;

auto now = std::chrono::steady_clock::now();

// Same ~80ms throttle as update_bytes(); there is no "100%" early-out here

// because there is no known total.

if (now - lastDraw_ < std::chrono::milliseconds(80)) return;

lastDraw_ = now;

// Before any byte arrives we only have "connecting…"; once the body starts

// streaming (no Content-Length) show the running byte count instead. The

// ticking elapsed-seconds suffix proves the line is alive either way.

std::string info = current_bytes > 0 ? fmt_bytes(current_bytes)

: std::string{"connecting…"};

if (elapsed_sec > 0)

info += std::format(" {:.0f}s", elapsed_sec);

auto frame = static_cast<std::size_t>(elapsed_sec * 6.0);

render_line_swept(frame, info);

if (finished_) return;

finished_ = true;

if (g_quiet) return;

// Clear the line and re-emit as a static info line.

std::print("\r\033[2K");

info(verb_, label_);

if (finished_) return;

finished_ = true;

if (g_quiet) return;

std::print("\r\033[2K");

info(verb_, final_message);

if (bar_) bar_->finish();

bar_.reset();

active_.clear();

double elapsed_sec) {

if (files.empty()) return;

// 1. Retire newly-finished entries. Each file's finished=true is reported

// twice (xlings quirk); the `finished_` set dedupes that and the case

// where the same file reappears at a different slot in a later event.

for (auto& f : files) {

if (finished_.contains(f.name)) continue;

if (!f.finished) continue;

if (active_ == f.name) {

if (bar_) bar_->finish();

bar_.reset();

active_.clear();

}

finished_.insert(f.name);

}

// 2. Pick what to display: keep showing `active_` if it's still streaming,

// else the first started+unfinished file. This stops the bar from

// flickering between names when files[] reshuffles across events during

// a multi-package install.

const DownloadFile* current = nullptr;

for (auto& f : files) {

if (f.name == active_ && !f.finished && !finished_.contains(f.name)) {

current = &f;

break;

}

}

if (!current) {

for (auto& f : files) {

if (finished_.contains(f.name)) continue;

if (f.started && !f.finished) { current = &f; break; }

}

}

if (!current) return;

if (current->name != active_) {

if (bar_) bar_->finish();

active_ = current->name;

bar_.emplace("Downloading", current->name);

}

if (current->total > 0) {

bar_->update_bytes(current->downloaded, current->total, elapsed_sec);

} else {

// Size not known yet (connecting / no Content-Length): keep the line

// animated instead of frozen.

bar_->update_indeterminate(current->downloaded, elapsed_sec);

}

namespace fs = std::filesystem;

// Use a pure string-prefix comparison rather than fs::relative —

// fs::relative internally canonicalises both arguments, which would

// resolve symlinks. We want to display the path the user thinks they

// are working with (e.g. `<MCPP_HOME>/registry/data/xpkgs/<pkg>` even

// when xpkgs/ is symlinked to a system xlings cache), so we keep

// every comparison purely lexical.

auto can = p.lexically_normal().generic_string();

auto rel_to = [&](const fs::path& base) -> std::optional<std::string> {

if (base.empty()) return std::nullopt;

auto bs = base.lexically_normal().generic_string();

// Strip trailing slashes on the base so "/x/y" and "/x/y/" match

// the same set of candidate paths.

while (!bs.empty() && bs.back() == '/') bs.pop_back();

if (bs.empty()) return std::nullopt;

if (can == bs) return std::string{};

if (can.size() > bs.size()

&& can.compare(0, bs.size(), bs) == 0

&& can[bs.size()] == '/') {

return can.substr(bs.size() + 1);

}

return std::nullopt;

};

if (auto r = rel_to(ctx.project_root); r) {

// Project-relative — print bare ("target/release/foo"), no prefix.

return r->empty() ? std::string{"."} : *r;

}

if (auto r = rel_to(ctx.mcpp_home); r) {

return r->empty() ? std::string{"@mcpp"} : "@mcpp/" + *r;

}

if (auto r = rel_to(ctx.home); r) {

return r->empty() ? std::string{"~"} : "~/" + *r;

}

return can;