{

if (text.empty())

return;

std::cerr << YELLOW

<< "hint: "

<< RESET

<< text

<< "\n";

const fs::path &file,

std::size_t line,

std::size_t contextLines,

std::size_t maxLineWidth)

{

std::vector<std::string> out;

if (file.empty() || line == 0)

return out;

std::ifstream in(file);

if (!in)

return out;

const std::size_t startLine =

line > contextLines ? line - contextLines : 1;

const std::size_t endLine = line + contextLines;

std::string current;

std::size_t currentLine = 0;

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

{

++currentLine;

if (currentLine < startLine)

continue;

if (currentLine > endLine)

break;

if (maxLineWidth > 0 && current.size() > maxLineWidth)

{

current = current.substr(0, maxLineWidth);

current += "...";

}

out.push_back(current);

}

return out;

const vix::cli::errors::CompilerError &err)

{

const std::string &message = err.message;

if (message.find("No such file or directory") != std::string::npos ||

message.find("file not found") != std::string::npos)

{

return "Check that the header exists and that its directory is listed in include_dirs, target_include_directories, or your compiler include paths.";

}

if (message.find("fatal error:") != std::string::npos &&

message.find("#include") != std::string::npos)

{

return "A header could not be found. Check the include path or the header name.";

}

if (message.find("use of undeclared identifier 'std'") != std::string::npos)

{

return "Include the required standard header before using std names.";

}

if (message.find("use of undeclared identifier") != std::string::npos)

{

return "Declare the symbol before use, include the right header, or check the namespace.";

}

if (message.find("was not declared in this scope") != std::string::npos)

{

return "Declare the symbol before use, include the right header, or move the function definition above the call.";

}

if (message.find("does not name a type") != std::string::npos)

{

return "Check that the type is declared before use and that the correct header is included.";

}

if (message.find("expected ';'") != std::string::npos)

{

return "Add the missing semicolon, often on the previous line.";

}

if (message.find("expected primary-expression") != std::string::npos)

{

return "Check the expression syntax near this location, especially missing operators, parentheses, or variables.";

}

if (message.find("no matching function for call to") != std::string::npos)

{

const bool isVixJson =

message.find("vix::http::ResponseWrapper::json") != std::string::npos ||

message.find("ResponseWrapper::json") != std::string::npos;

if (isVixJson)

return "Response::json() expects one JSON value, not key/value arguments.";

return "Check argument types, overloads, const qualifiers, and references.";

}

if (message.find("undefined reference to") != std::string::npos)

{

return "A symbol is declared but not linked. Check missing .cpp files, libraries, or target_link_libraries.";

}

if (message.find("defined but not used") != std::string::npos)

{

return "Remove the unused function or mark it intentionally unused.";

}

return {};

const vix::cli::errors::CompilerError &err,

const std::string &contextMessage)

{

vix::cli::build::BuildDiagnostic diagnostic;

diagnostic.title =

contextMessage.empty()

? "Build failed"

: contextMessage;

diagnostic.error = err.message;

diagnostic.hint = hint_for_compiler_error(err);

diagnostic.location.file = err.file;

diagnostic.location.line =

err.line > 0 ? static_cast<std::size_t>(err.line) : 0;

diagnostic.location.column =

err.column > 0 ? static_cast<std::size_t>(err.column) : 0;

diagnostic.codeFrame.location = diagnostic.location;

diagnostic.codeFrame.lines =

read_code_frame_lines(

fs::path(err.file),

diagnostic.location.line,

2,

120);

return diagnostic;

std::string_view log)

{

const std::size_t pos =

log.find("unrecognized command-line option");

if (pos == std::string_view::npos)

return false;

std::string option;

const std::size_t openQuote = log.find("‘", pos);

std::size_t closeQuote = std::string_view::npos;

if (openQuote != std::string_view::npos)

closeQuote = log.find("’", openQuote + 1);

if (openQuote != std::string_view::npos &&

closeQuote != std::string_view::npos &&

closeQuote > openQuote + 1)

{

option =

std::string(log.substr(openQuote + 1, closeQuote - (openQuote + 1)));

}

if (option.size() < 3 || option.rfind("--", 0) != 0)

return false;

std::cerr << RED

<< "error: runtime argument passed as compiler flag"

<< RESET << "\n";

print_hint("use --args for runtime arguments in .cpp script mode");

std::cerr << GREEN

<< "at: "

<< RESET

<< "vix run <file.cpp> --args " << option << "\n";

return true;

{

if (pos == std::string_view::npos)

return std::string_view::npos;

while (pos > 0 && text[pos - 1] != '\n')

--pos;

return pos;

{

static constexpr std::string_view anchors[] = {

"FAILED:",

"ninja: build stopped:",

"fatal error:",

"error:",

"CMake Error",

"make: ***",

};

std::size_t best = std::string_view::npos;

for (const auto anchor : anchors)

{

const std::size_t pos = log.find(anchor);

if (pos == std::string_view::npos)

continue;

std::size_t start = line_start(log, pos);

if (start == std::string_view::npos)

start = 0;

if (best == std::string_view::npos || start < best)

best = start;

}

if (best == std::string_view::npos)

{

const std::size_t pos = log.find(": error:");

if (pos != std::string_view::npos)

{

const std::size_t start = line_start(log, pos);

best = start == std::string_view::npos ? 0 : start;

}

}

return best;

{

const std::string_view view(log);

const std::size_t start = find_first_error_anchor(view);

if (start == std::string_view::npos)

return log;

return std::string(view.substr(start));

const std::string &buildLog,

const fs::path &sourceFile,

const std::string &contextMessage)

{

using namespace vix::cli::errors;

const std::string cleanedLog = ::trim_build_preamble(buildLog);

auto errors = ClangGccParser::parse(cleanedLog);

if (errors.empty())

{

if (handle_unrecognized_cli_option_as_script_runtime_args(cleanedLog))

return true;

if (vix::cli::errors::build::handleBuildErrors(cleanedLog))

return true;

if (RawLogDetectors::handleLinkerOrSanitizer(

cleanedLog,

sourceFile,

contextMessage))

{

return true;

}

vix::cli::build::print_build_error(

std::cerr,

contextMessage.empty() ? "Build failed" : contextMessage);

print_hint("run with --verbose to inspect the full build output");

const bool debugOutput = []()

{

const char *level = std::getenv("VIX_LOG_LEVEL");

if (!level || !*level)

return false;

std::string value(level);

for (char &c : value)

c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));

return value == "debug" || value == "trace";

}();

if (debugOutput && !cleanedLog.empty())

{

std::cerr << "\n"

<< GRAY

<< "compiler output:"

<< RESET

<< "\n";

std::cerr << cleanedLog;

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

std::cerr << "\n";

}

else

{

print_hint("run with VIX_LOG_LEVEL=debug to inspect the full compiler output");

}

return false;

}

ErrorContext ctx{sourceFile, contextMessage, cleanedLog};

ErrorPipeline pipeline;

if (pipeline.tryHandle(errors, ctx))

return true;

std::unordered_map<std::string, int> counts;

counts.reserve(errors.size());

for (const auto &err : errors)

{

const std::string key = err.file + "|" + err.message;

++counts[key];

}

std::vector<CompilerError> unique;

unique.reserve(errors.size());

std::unordered_set<std::string> seen;

seen.reserve(errors.size());

for (const auto &err : errors)

{

const std::string key = err.file + "|" + err.message;

if (seen.insert(key).second)

unique.push_back(err);

}

if (unique.empty())

{

std::cerr << RED

<< "error: "

<< RESET

<< contextMessage

<< "\n";

print_hint("no unique compiler error was detected; inspect the raw compiler output");

if (!cleanedLog.empty())

std::cerr << cleanedLog << "\n";

return false;

}

std::cerr << RED

<< "error: "

<< RESET

<< contextMessage

<< "\n";

CodeFrameOptions codeFrameOptions;

codeFrameOptions.contextLines = 2;

codeFrameOptions.maxLineWidth = 120;

codeFrameOptions.tabWidth = 4;

const std::size_t maxToShow =

std::min<std::size_t>(unique.size(), 3);

for (std::size_t i = 0; i < maxToShow; ++i)

{

const auto &err = unique[i];

const vix::cli::build::BuildDiagnostic diagnostic =

::diagnostic_from_compiler_error(

err,

contextMessage);

vix::cli::build::print_build_diagnostic(

std::cerr,

diagnostic);

const std::string key = err.file + "|" + err.message;

const auto it = counts.find(key);

if (it != counts.end() && it->second > 1)

{

vix::cli::build::print_build_warning(

std::cerr,

std::to_string(it->second - 1) + " similar error(s) hidden");

}

}

if (unique.size() > maxToShow)

{

std::cerr << "\n"

<< GRAY

<< (unique.size() - maxToShow)

<< " more distinct error(s) hidden. Run with --verbose for full output."

<< RESET

<< "\n";

}

if (!sourceFile.empty())

{

vix::cli::build::print_build_info(

std::cerr,

"at: " + sourceFile.string());

}

return true;