use solcompat_core::{Outcome, Report, Severity};
use std::{ffi::OsString, fmt::Write};
const RESET: &str = "\x1b[0m";
const BOLD_GREEN: &str = "\x1b[1;32m";
const BOLD_RED: &str = "\x1b[1;31m";
const BOLD_YELLOW: &str = "\x1b[1;33m";
const BOLD_CYAN: &str = "\x1b[1;36m";
const BOLD_MAGENTA: &str = "\x1b[1;35m";
const DIM: &str = "\x1b[2m";
fn paint(value: &str, color: &str, enabled: bool) -> String {
if enabled {
format!("{color}{value}{RESET}")
} else {
value.into()
}
}
pub fn error(message: &str, color: bool) -> String {
format!("{} — {message}", paint("ERROR", BOLD_RED, color))
}
fn one_line(value: &str) -> String {
value
.chars()
.flat_map(|c| {
if c.is_control() || matches!(c, '\u{202a}'..='\u{202e}' | '\u{2066}'..='\u{2069}') {
c.escape_unicode().to_string().chars().collect::<Vec<_>>()
} else {
vec![c]
}
})
.collect()
}
fn quote(value: &str) -> String {
if !value.is_empty()
&& value
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b"-_=./:".contains(&b))
{
value.into()
} else {
format!("'{}'", value.replace('\'', "'\"'\"'"))
}
}
fn counted(count: usize, singular: &str, plural: &str) -> String {
format!("{count} {}", if count == 1 { singular } else { plural })
}
pub fn detailed_hint(args: impl Iterator<Item = OsString>) -> String {
let mut args: Vec<_> = args.map(|arg| quote(&arg.to_string_lossy())).collect();
if args.len() == 1 {
args.push("check".into());
}
if !args.iter().any(|arg| arg == "--detailed") {
args.push("--detailed".into());
}
args.join(" ")
}
pub fn report(report: &Report, detailed: bool, hint: &str, color: bool) -> String {
let mut out = String::new();
let has_visible_results = report
.results
.iter()
.any(|result| result.outcome != Outcome::NotApplicable);
writeln!(
out,
"SolCompat — {} · {}",
one_line(&report.project.name),
match report.command.as_str() {
"inspect" => "inventory",
"upgrade" => "upgrade advisor",
_ if report
.results
.iter()
.any(|result| result.operation == "build") =>
{
"compatibility + build"
}
_ => "compatibility scan",
}
)
.unwrap();
writeln!(out, "Target: {}", report.target).unwrap();
if report.command != "inspect" {
let (verdict, verdict_color) = if report.command == "upgrade" && report.counts.errors > 0 {
("BREAKING CHANGES DETECTED", BOLD_RED)
} else if report.command == "upgrade" && report.counts.warnings > 0 {
("UPGRADE REVIEW NEEDED", BOLD_YELLOW)
} else if report.counts.errors > 0 {
("INCOMPATIBLE FOR CHECKED RULES", BOLD_RED)
} else if (report.counts.unknown > 0 || report.counts.skipped > 0)
&& report.policy.deny_unknown
{
("FAILED POLICY — INPUT REQUIRED", BOLD_RED)
} else if report.counts.unknown > 0 || report.counts.skipped > 0 {
("INCOMPLETE", BOLD_YELLOW)
} else if report.counts.warnings > 0 && report.policy.deny_warnings {
("FAILED POLICY — WARNINGS DENIED", BOLD_RED)
} else if report.counts.warnings > 0 {
("PASSED WITH WARNINGS", BOLD_YELLOW)
} else if report.counts.info > 0 {
("PASSED WITH NOTES", BOLD_CYAN)
} else if report.counts.suppressed > 0 {
("REVIEW SUPPRESSIONS", BOLD_MAGENTA)
} else if !has_visible_results && report.command == "upgrade" {
("NO APPLICABLE UPGRADE ADVICE", DIM)
} else if !has_visible_results {
("NO APPLICABLE CHECKS", DIM)
} else {
("COMPATIBLE FOR CHECKED RULES", BOLD_GREEN)
};
writeln!(out, "Verdict: {}", paint(verdict, verdict_color, color)).unwrap();
writeln!(
out,
"Scope: {} · {} · {} · {}",
counted(report.project.programs.len(), "program", "programs"),
counted(report.project.clients.len(), "client", "clients"),
counted(report.project.idls.len(), "IDL", "IDLs"),
counted(report.project.artifacts.len(), "artifact", "artifacts")
)
.unwrap();
if !has_visible_results {
writeln!(
out,
"{}",
if report.command == "upgrade" {
"No reviewed migration advice applies to the detected components and selected targets."
} else {
"No configured checks apply to the detected components and selected target."
}
)
.unwrap();
if report
.project
.programs
.iter()
.any(|program| program.framework == "pinocchio")
{
writeln!(
out,
"Pinocchio checks require an explicit sBPFv3 build profile (SC103) or a supplied artifact with an applicable target (SC102). Builds and target/ outputs are not imported automatically in v0.1."
)
.unwrap();
}
}
if report.counts.warnings > 0
&& report.counts.errors == 0
&& report.counts.unknown == 0
&& report.counts.skipped == 0
{
writeln!(
out,
"No incompatibility was detected; {} should be reviewed.",
counted(
report.counts.warnings,
"advisory warning",
"advisory warnings"
)
)
.unwrap();
}
if report.counts.unknown > 0 && report.counts.errors == 0 {
writeln!(
out,
"No incompatibility was detected, but {} could not be completed.",
counted(report.counts.unknown, "check", "checks")
)
.unwrap();
}
}
if detailed {
if let Some(digest) = &report.target_digest {
writeln!(out, "Target data: {digest}").unwrap();
}
}
if report.command == "inspect" {
for client in &report.project.clients {
writeln!(
out,
"\nCLIENT {} — {}",
one_line(&client.id),
one_line(&client.manifest)
)
.unwrap();
for (package, requirement) in &client.dependencies {
writeln!(
out,
" {}: {} (declared)",
one_line(package),
one_line(requirement)
)
.unwrap();
}
for (package, version) in &client.resolved_dependencies {
writeln!(
out,
" {}: {} (resolved)",
one_line(package),
one_line(version)
)
.unwrap();
}
writeln!(out, " RPC read contracts: {}", client.rpc_reads.len()).unwrap();
}
for program in &report.project.programs {
writeln!(
out,
"\nPROGRAM CANDIDATE {} — {}",
one_line(&program.id),
one_line(&program.manifest)
)
.unwrap();
writeln!(
out,
" Framework: {} ({})",
one_line(&program.framework),
one_line(&program.candidate_reason)
)
.unwrap();
for (package, version) in &program.resolved_dependencies {
writeln!(
out,
" {}: {} (resolved)",
one_line(package),
one_line(version)
)
.unwrap();
}
}
for idl in &report.project.idls {
writeln!(
out,
"\nIDL {} — {} ({})",
one_line(&idl.id),
one_line(&idl.path),
one_line(&idl.schema)
)
.unwrap();
}
for artifact in &report.project.artifacts {
writeln!(
out,
"\nARTIFACT {} — {} (sBPF{})",
one_line(&artifact.id),
one_line(&artifact.path),
one_line(artifact.sbpf_version.as_deref().unwrap_or("unknown"))
)
.unwrap();
}
for tool in &report.project.tools {
writeln!(
out,
"\nTOOL {} — {}",
one_line(&tool.tool),
one_line(tool.version.as_deref().unwrap_or(&tool.status))
)
.unwrap();
}
writeln!(
out,
"\n{} component(s) inspected; no compatibility checks executed.",
report.project.clients.len() + report.project.programs.len()
)
.unwrap();
return out.trim_end().into();
}
if detailed {
writeln!(
out,
"Data: {} ({})",
one_line(&report.dataset.revision),
report.dataset.digest
)
.unwrap();
}
if detailed && has_visible_results {
writeln!(
out,
"Status: {} verified · {} incompatible · {} review · {} insufficient evidence",
paint("PASS", BOLD_GREEN, color),
paint("ERROR", BOLD_RED, color),
paint("WARNING", BOLD_YELLOW, color),
paint("NEEDS INPUT", BOLD_YELLOW, color)
)
.unwrap();
}
if has_visible_results {
out.push('\n');
}
for result in &report.results {
if result.outcome == Outcome::NotApplicable {
continue;
}
let (status, status_color) = if result.suppression.is_some() {
("SUPPRESSED", BOLD_MAGENTA)
} else {
match result.outcome {
Outcome::Pass => ("PASS", BOLD_GREEN),
Outcome::Unknown => ("NEEDS INPUT", BOLD_YELLOW),
Outcome::NotApplicable => ("N/A", DIM),
Outcome::Skipped => ("SKIPPED", BOLD_CYAN),
Outcome::Finding => match result.severity {
Some(Severity::Error) if report.command == "upgrade" => ("BREAKING", BOLD_RED),
Some(Severity::Error) => ("ERROR", BOLD_RED),
Some(Severity::Warning) => ("WARNING", BOLD_YELLOW),
_ => ("INFO", BOLD_CYAN),
},
}
};
let title = if detailed {
&result.title
} else {
&result.rule_name
};
writeln!(
out,
"{}{} — {} ({}) · {}",
paint(status, status_color, color),
if result.conditional {
" [CONDITIONAL]"
} else {
""
},
one_line(title),
result.rule_id,
one_line(&result.subject)
)
.unwrap();
writeln!(out, " {}", one_line(&result.summary)).unwrap();
if let Some(suppression) = &result.suppression {
writeln!(out, " Suppressed: {}", one_line(&suppression.reason)).unwrap();
}
if detailed {
writeln!(out, " Why: {}", one_line(&result.explanation)).unwrap();
for evidence in &result.evidence {
writeln!(
out,
" Evidence: {} [{}; {}]",
one_line(&evidence.path),
one_line(&evidence.pointer),
one_line(&evidence.kind)
)
.unwrap();
}
if let Some(fix) = &result.remediation {
writeln!(
out,
" Next: {}\n Where: {}",
one_line(&fix.summary),
one_line(&fix.location)
)
.unwrap();
for (index, step) in fix.steps.iter().enumerate() {
writeln!(out, " {}. {}", index + 1, one_line(step)).unwrap();
}
if let Some(example) = &fix.example {
writeln!(out, " Example:").unwrap();
for line in example.lines() {
writeln!(out, " {}", one_line(line)).unwrap();
}
}
for step in &fix.verification {
writeln!(out, " Verify: {}", one_line(step)).unwrap();
}
}
for source in &result.sources {
writeln!(out, " Reference: {}", one_line(source)).unwrap();
}
} else if let Some(fix) = &result.remediation {
writeln!(out, " Next: {}", one_line(&fix.summary)).unwrap();
}
out.push('\n');
}
let c = &report.counts;
let counts = [
(c.passed, "passed", "passed"),
(c.errors, "error", "errors"),
(c.warnings, "warning", "warnings"),
(c.info, "info", "info"),
(c.unknown, "check needs input", "checks need input"),
(c.skipped, "skipped", "skipped"),
(c.suppressed, "suppressed", "suppressed"),
]
.into_iter()
.filter(|(count, _, _)| *count > 0)
.map(|(count, singular, plural)| {
format!("{count} {}", if count == 1 { singular } else { plural })
})
.collect::<Vec<_>>()
.join(" · ");
if !counts.is_empty() {
writeln!(out, "{counts}").unwrap();
}
writeln!(out, "Exit code: {}", report.exit_code).unwrap();
if !detailed && has_visible_results {
writeln!(out, "Details: {}", one_line(hint)).unwrap();
}
out.trim_end().into()
}