{

int code{0};

std::string diagnostics;

{

fs::path projectDir;

bool quiet{false};

bool verbose{false};

{

process::Plan plan;

std::string sdkResolutionError;

{

Rebuilt,

Reconfigured

{

if (ms > 0 && ms < 1000)

return std::to_string(ms) + "ms";

return util::format_seconds(ms);

const fs::path &path,

const fs::path &projectDir)

{

std::error_code ec;

fs::path relative = fs::relative(path, projectDir, ec);

if (ec || relative.empty())

relative = path.lexically_normal().lexically_relative(projectDir);

if (relative.empty())

relative = path.filename();

return relative.lexically_normal().generic_string();

{

const std::string name = path.filename().string();

const std::string ext = path.extension().string();

return name == "CMakeLists.txt" ||

name == "CMakePresets.json" ||

name == "CMakeUserPresets.json" ||

name == "vix.app" ||

name == "vix.json" ||

name == "vix.toml" ||

name == "vix.lock" ||

name == "vix.module" ||

ext == ".cmake";

const vix::engine::watch::Batch &batch)

{

std::vector<vix::engine::watch::Event> events;

for (const auto &event : batch.events)

{

if (event.kind == vix::engine::watch::EventKind::Overflow)

continue;

if (event.path.empty())

continue;

events.push_back(event);

}

std::sort(

events.begin(),

events.end(),

[](const auto &a, const auto &b)

{

return a.path.lexically_normal().generic_string() <

b.path.lexically_normal().generic_string();

});

return events;

const vix::engine::watch::Batch &batch,

const fs::path &projectDir,

bool configurationChange,

bool structuralChange)

{

const auto events = watch_effective_events(batch);

if (events.empty())

{

if (configurationChange)

return "build configuration";

if (structuralChange)

return "project structure";

return "project";

}

if (events.size() == 1)

{

const auto &event = events.front();

if (event.kind == vix::engine::watch::EventKind::Renamed &&

!event.oldPath.empty())

{

return watch_relative_path(event.oldPath, projectDir) +

" -> " +

watch_relative_path(event.path, projectDir);

}

return watch_relative_path(event.path, projectDir);

}

if (configurationChange)

return "build configuration";

if (structuralChange)

return "project structure";

return std::to_string(events.size()) + " files";

const vix::engine::watch::Batch &batch)

{

for (const auto &event : batch.events)

{

if (watch_is_config_path(event.path) ||

(!event.oldPath.empty() && watch_is_config_path(event.oldPath)))

{

return true;

}

}

return batch.overflowed;

const fs::path &path,

const fs::path &root)

{

const fs::path p = path.lexically_normal();

const fs::path r = root.lexically_normal();

auto pit = p.begin();

auto rit = r.begin();

for (; rit != r.end(); ++rit, ++pit)

{

if (pit == p.end() || *pit != *rit)

return false;

}

return true;

const fs::path &path,

const std::vector<fs::path> &ignoredRoots)

{

const fs::path normalized = path.lexically_normal();

for (const fs::path &root : ignoredRoots)

{

if (!root.empty() && watch_path_within(normalized, root))

return true;

}

for (const fs::path &part : normalized)

{

const std::string item = part.string();

if (item == ".git" ||

item == ".hg" ||

item == ".svn" ||

item == ".vix" ||

item == "node_modules" ||

item == ".cache" ||

item == ".idea" ||

item == ".vscode" ||

item == "CMakeFiles")

{

return true;

}

}

const std::string name = normalized.filename().string();

return name == "compile_commands.json" ||

name == "build.ninja" ||

name == "CMakeCache.txt" ||

name == "configure.log" ||

name == "build.log";

{

public:

WatchContentFingerprints(

fs::path root,

std::vector<fs::path> ignoredRoots)

: root_(std::move(root)),

ignoredRoots_(std::move(ignoredRoots))

{

}

void seed()

{

std::error_code ec;

root_ = fs::absolute(root_, ec).lexically_normal();

if (ec || root_.empty() || !fs::exists(root_, ec))

return;

if (fs::is_regular_file(root_, ec))

{

remember(root_);

return;

}

fs::recursive_directory_iterator it(

root_,

fs::directory_options::skip_permission_denied,

ec);

const fs::recursive_directory_iterator end;

while (!ec && it != end)

{

const fs::path current = it->path().lexically_normal();

if (watch_content_fingerprint_skip_path(current, ignoredRoots_))

{

if (it->is_directory(ec))

it.disable_recursion_pending();

++it;

continue;

}

if (it->is_regular_file(ec))

remember(current);

++it;

}

}

vix::engine::watch::Batch filter(

const vix::engine::watch::Batch &batch)

{

if (batch.empty() || batch.overflowed)

return batch;

vix::engine::watch::Batch filtered;

std::map<std::string, std::optional<std::string>> batchHashes;

for (const auto &event : batch.events)

{

if (event.directory ||

event.kind == vix::engine::watch::EventKind::Overflow)

{

filtered.events.push_back(event);

continue;

}

const fs::path path = event.path.lexically_normal();

const std::string key = path.generic_string();

if (event.kind == vix::engine::watch::EventKind::Removed)

{

hashes_.erase(key);

filtered.events.push_back(event);

continue;

}

if (event.kind == vix::engine::watch::EventKind::Added)

{

const std::optional<std::string> hash =

hash_from_cache(path, batchHashes);

if (!hash)

{

hashes_.erase(key);

filtered.events.push_back(event);

continue;

}

const auto previous = hashes_.find(key);

const bool unchanged =

previous != hashes_.end() && previous->second == *hash;

hashes_[key] = *hash;

if (unchanged)

continue;

filtered.events.push_back(event);

continue;

}

if (event.kind != vix::engine::watch::EventKind::Modified &&

event.kind != vix::engine::watch::EventKind::Renamed)

{

remember_from_cache(path, batchHashes);

filtered.events.push_back(event);

continue;

}

const std::optional<std::string> hash =

hash_from_cache(path, batchHashes);

if (!hash)

{

hashes_.erase(key);

filtered.events.push_back(event);

continue;

}

const auto previous = hashes_.find(key);

const bool unchanged =

previous != hashes_.end() && previous->second == *hash;

hashes_[key] = *hash;

if (event.kind == vix::engine::watch::EventKind::Renamed &&

!event.oldPath.empty())

{

hashes_.erase(event.oldPath.lexically_normal().generic_string());

}

if (unchanged)

continue;

filtered.events.push_back(event);

}

return filtered;

}

private:

void remember(const fs::path &path)

{

std::error_code ec;

if (!fs::is_regular_file(path, ec) || ec)

return;

const auto hash = util::read_file_hash_hex(path);

if (hash)

hashes_[path.lexically_normal().generic_string()] = *hash;

}

std::optional<std::string> hash_from_cache(

const fs::path &path,

std::map<std::string, std::optional<std::string>> &batchHashes)

{

const std::string key = path.lexically_normal().generic_string();

const auto cached = batchHashes.find(key);

if (cached != batchHashes.end())

return cached->second;

std::error_code ec;

std::optional<std::string> hash;

if (fs::is_regular_file(path, ec) && !ec)

hash = util::read_file_hash_hex(path);

batchHashes.emplace(key, hash);

return hash;

}

void remember_from_cache(

const fs::path &path,

std::map<std::string, std::optional<std::string>> &batchHashes)

{

const auto hash = hash_from_cache(path, batchHashes);

if (hash)

hashes_[path.lexically_normal().generic_string()] = *hash;

}

fs::path root_;

std::vector<fs::path> ignoredRoots_;

std::map<std::string, std::string> hashes_;

const WatchDisplayContext &display,

const std::string &line,

std::ostream &out = std::cout)

{

if (display.quiet)

return;

out << line << "\n";

out.flush();

{

#ifdef _WIN32

return ::_isatty(1) != 0;

#else

return ::isatty(STDOUT_FILENO) != 0;

#endif

{

#ifdef _WIN32

return 100;

#else

struct winsize ws{};

if (::ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0)

return static_cast<int>(ws.ws_col);

return 100;

#endif

const std::string &value,

int width)

{

if (width <= 0)

return {};

if (static_cast<int>(value.size()) <= width)

return value;

if (width <= 3)

return value.substr(0, static_cast<std::size_t>(width));

return "..." + value.substr(value.size() - static_cast<std::size_t>(width - 3));

const std::string &subject,

int reservedColumns)

{

if (!watch_stdout_is_tty())

return subject;

const int columns = watch_terminal_columns();

const int subjectWidth = std::max(12, columns - reservedColumns);

return watch_truncate_plain(subject, subjectWidth);

const char *color,

const std::string &label)

{

std::ostringstream out;

out << color << BOLD

<< label

<< RESET

<< " ";

return out.str();

const WatchDisplayContext &display,

const std::string &target)

{

std::ostringstream line;

line << watch_label(CYAN, "Watching")

<< WATCH_PRIMARY << BOLD << target << RESET;

watch_print_line(display, line.str());

const WatchDisplayContext &display,

std::ostream &out = std::cout)

{

std::ostringstream line;

line << watch_label(GRAY, "Waiting")

<< GRAY << "for changes"

<< " "

<< "(Ctrl+C to stop)"

<< RESET;

watch_print_line(display, line.str(), out);

{

constexpr std::string_view prefix = "-fuse-ld=";

if (linker.rfind(prefix, 0) == 0)

return linker.substr(prefix.size());

return linker;

const WatchDisplayContext &display,

const fs::path &buildDir)

{

const fs::path normalizedBuildDir =

fs::absolute(buildDir).lexically_normal();

const fs::path normalizedProjectDir =

fs::absolute(display.projectDir).lexically_normal();

const std::string build = normalizedBuildDir.string();

const std::string project = normalizedProjectDir.string();

if (!project.empty() &&

build.size() > project.size() &&

build.compare(0, project.size(), project) == 0 &&

build[project.size()] == fs::path::preferred_separator)

{

return fs::relative(normalizedBuildDir, normalizedProjectDir).string();

}

return buildDir.string();

const WatchDisplayContext &display,

const std::string &backend,

const fs::path &buildDir,

const std::string &target,

int jobs,

const std::optional<std::string> &launcher,

const std::optional<std::string> &linker)

{

if (display.quiet)

return;

std::ostringstream first;

first << " " << CYAN << "backend " << RESET

<< WATCH_PRIMARY << backend << RESET

<< YELLOW << " · " << RESET

<< CYAN << "target " << RESET

<< WATCH_PRIMARY << target << RESET

<< YELLOW << " · " << RESET

<< CYAN << "jobs " << RESET

<< WATCH_PRIMARY << jobs << RESET;

watch_print_line(display, first.str());

std::ostringstream second;

second << " " << CYAN << "build " << RESET

<< WATCH_PRIMARY << watch_relative_build_dir(display, buildDir)

<< RESET;

if (launcher)

second << YELLOW << " · " << RESET

<< CYAN << "launcher " << RESET

<< WATCH_PRIMARY << *launcher << RESET;

if (linker)

second << YELLOW << " · " << RESET

<< CYAN << "linker " << RESET

<< WATCH_PRIMARY << watch_normalize_linker(*linker) << RESET;

watch_print_line(display, second.str());

const WatchDisplayContext &display,

std::size_t affectedTasks)

{

std::ostringstream line;

line << " " << YELLOW << affectedTasks << RESET

<< GRAY << " affected tasks" << RESET;

watch_print_line(display, line.str());

const WatchDisplayContext &display)

{

if (display.quiet)

return;

std::cout << RESET;

if (watch_stdout_is_tty())

std::cout << "\n";

std::cout << std::flush;

{

public:

WatchProgressLine(

const WatchDisplayContext &display,

const vix::engine::watch::Batch &batch,

WatchDisplayAction action,

bool structuralChange,

std::string detail = {})

: active_(!display.quiet && watch_stdout_is_tty()),

subject_(

watch_change_subject(

batch,

display.projectDir,

action == WatchDisplayAction::Reconfigured,

structuralChange)),

action_(action),

detail_(std::move(detail)),

started_(std::chrono::steady_clock::now())

{

verb_ =

action_ == WatchDisplayAction::Reconfigured

? "Configuring"

: "Building";

if (!active_)

return;

worker_ = std::thread(

[this]()

{

while (!stop_.load())

{

render();

std::this_thread::sleep_for(std::chrono::milliseconds(120));

}

});

}

~WatchProgressLine()

{

stop();

}

WatchProgressLine(const WatchProgressLine &) = delete;

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

void update(

std::string verb,

std::string subject,

std::string detail = {})

{

if (!active_)

return;

std::lock_guard<std::mutex> lock(mutex_);

verb_ = std::move(verb);

subject_ = std::move(subject);

detail_ = std::move(detail);

}

void stop()

{

if (!active_)

return;

stop_.store(true);

if (worker_.joinable())

worker_.join();

std::cout << "\r\033[2K" << std::flush;

active_ = false;

}

private:

void render()

{

const auto ms =

std::chrono::duration_cast<std::chrono::milliseconds>(

std::chrono::steady_clock::now() - started_)

.count();

std::string verb;

std::string subject;

std::string detail;

{

std::lock_guard<std::mutex> lock(mutex_);

verb = verb_;

subject = subject_;

detail = detail_;

}

const int columns = watch_terminal_columns();

const std::string duration = watch_format_duration(ms);

const int reservedColumns =

static_cast<int>(

verb.size() +

std::string(" ").size() +

duration.size() +

(detail.empty() ? 0 : detail.size() + 3));

const int subjectWidth = std::max(12, columns - reservedColumns);

std::ostringstream line;

line << verb << " "

<< watch_truncate_plain(subject, subjectWidth);

if (!detail.empty())

line << " (" << detail << ")";

line << " " << duration;

std::cout << "\r\033[2K"

<< watch_truncate_plain(line.str(), columns)

<< std::flush;

}

bool active_{false};

std::atomic<bool> stop_{false};

std::thread worker_;

std::mutex mutex_;

std::string verb_{"Building"};

std::string subject_;

WatchDisplayAction action_{WatchDisplayAction::Rebuilt};

std::string detail_;

std::chrono::steady_clock::time_point started_;

{

std::string name;

long long ms{0};

const std::vector<BuildPhaseTiming> &timings)

{

if (timings.empty())

return;

for (const BuildPhaseTiming &timing : timings)

{

std::cout << timing.name << ": "

<< watch_format_duration(timing.ms)

<< "\n";

}

std::cout.flush();

{

if (line.empty() || line.front() != '[')

return false;

const std::size_t slash = line.find('/');

const std::size_t close = line.find(']');

return slash != std::string::npos &&

close != std::string::npos &&

slash < close;

const std::string &diagnostics)

{

std::istringstream in(diagnostics);

std::ostringstream out;

std::string line;

while (std::getline(in, line))

{

if (line.rfind("ninja: Entering directory", 0) == 0)

continue;

if (line == "ninja: build stopped: subcommand failed.")

continue;

if (line.rfind("ninja -C ", 0) == 0)

continue;

if (line.rfind("FAILED: ", 0) == 0)

continue;

if (line.rfind("Unable to resolve a unique graph output target:", 0) == 0)

continue;

if (watch_is_ninja_progress_line(line))

continue;

if (line.rfind("/", 0) == 0 &&

line.find(" -c ") != std::string::npos)

continue;

if (line.rfind("ccache ", 0) == 0 &&

line.find(" -c ") != std::string::npos)

continue;

out << line << "\n";

}

return out.str();

const WatchDisplayContext &display,

const std::string &target,

long long ms)

{

watch_print_header(display, target);

std::ostringstream status;

status << watch_label(GREEN, "Finished")

<< "initial build"

<< GRAY << " in " << RESET

<< watch_duration_color(ms)

<< BOLD

<< watch_format_duration(ms)

<< RESET;

watch_print_line(display, status.str());

watch_print_waiting(display);

const WatchDisplayContext &display,

long long ms)

{

std::ostringstream status;

status << watch_label(GREEN, "Finished")

<< "initial build"

<< GRAY << " in " << RESET

<< watch_duration_color(ms)

<< BOLD

<< watch_format_duration(ms)

<< RESET;

watch_print_line(display, status.str());

const WatchDisplayContext &display,

const std::string &target,

const std::string &diagnostics)

{

watch_print_header(display, target);

std::ostringstream status;

status << watch_label(RED, "Error")

<< RED << BOLD << "initial build failed" << RESET;

watch_print_line(display, status.str(), std::cerr);

const std::string filtered =

watch_filter_failure_diagnostics(diagnostics);

if (!display.quiet && !filtered.empty())

{

std::cerr << filtered;

if (filtered.back() != '\n')

std::cerr << "\n";

std::cerr.flush();

}

watch_print_waiting(display, std::cerr);

const WatchDisplayContext &display,

const vix::engine::watch::Batch &batch,

WatchDisplayAction action,

bool structuralChange,

long long ms,

std::string detail = {},

std::string subjectOverride = {})

{

const bool configurationChange =

action == WatchDisplayAction::Reconfigured;

const std::string subject =

subjectOverride.empty()

? watch_change_subject(

batch,

display.projectDir,

configurationChange,

structuralChange)

: std::move(subjectOverride);

const char *labelColor = GREEN;

const char *verb = "";

if (configurationChange)

{

labelColor = CYAN;

verb = "reconfigured";

}

else if (structuralChange)

{