use crate::analysis::RetainedSizeAnalyzer;
use crate::parser::{parse_wasm, WasmItemKind};
use anyhow::{Context, Result};
use colored::Colorize;
use std::path::Path;
pub fn run(path: &Path, name: &str, depth: usize, json: bool) -> Result<()> {
let parsed = parse_wasm(path).context("Failed to parse WASM file")?;
let has_match = parsed.items.iter().any(|item| {
item.kind == WasmItemKind::Function
&& (item.name.contains(name) || item.raw_name.contains(name))
});
if !has_match {
if json {
println!(
"{}",
serde_json::json!({
"error": "no_match",
"message": format!("No items matching '{}' found", name),
"suggestions": find_suggestions(&parsed, name)
})
);
} else {
eprintln!(
"{}: No items matching '{}' found",
"Error".red().bold(),
name.yellow()
);
let suggestions = find_suggestions(&parsed, name);
if !suggestions.is_empty() {
eprintln!("\n{}", "Did you mean:".bold());
for s in suggestions.iter().take(5) {
eprintln!(" - {}", s);
}
}
}
return Ok(());
}
let analyzer = RetainedSizeAnalyzer::new(parsed);
let paths = analyzer.find_retention_paths(name, depth);
let matching: Vec<_> = analyzer
.parsed()
.items
.iter()
.filter(|item| {
item.kind == WasmItemKind::Function
&& (item.name.contains(name) || item.raw_name.contains(name))
})
.collect();
if json {
output_json(&paths, &matching)?;
} else {
output_human(&paths, &matching, name)?;
}
Ok(())
}
fn find_suggestions(parsed: &crate::parser::ParsedWasm, name: &str) -> Vec<String> {
let name_lower = name.to_lowercase();
let mut suggestions: Vec<_> = parsed
.items
.iter()
.filter(|item| item.kind == WasmItemKind::Function && item.size > 0)
.filter(|item| {
item.name.to_lowercase().contains(&name_lower)
|| name_lower
.chars()
.all(|c| item.name.to_lowercase().contains(c))
})
.map(|item| item.name.clone())
.collect();
suggestions.sort();
suggestions.dedup();
suggestions.truncate(10);
suggestions
}
fn output_json(
paths: &[crate::analysis::RetentionPath],
matching: &[&crate::parser::WasmItem],
) -> Result<()> {
#[derive(serde::Serialize)]
struct JsonOutput {
targets: Vec<TargetInfo>,
retention_paths: Vec<crate::analysis::RetentionPath>,
}
#[derive(serde::Serialize)]
struct TargetInfo {
name: String,
raw_name: String,
size: u64,
func_index: Option<u32>,
}
let targets: Vec<_> = matching
.iter()
.map(|item| TargetInfo {
name: item.name.clone(),
raw_name: item.raw_name.clone(),
size: item.size,
func_index: item.func_index,
})
.collect();
let output = JsonOutput {
targets,
retention_paths: paths.to_vec(),
};
println!("{}", serde_json::to_string_pretty(&output)?);
Ok(())
}
fn output_human(
paths: &[crate::analysis::RetentionPath],
matching: &[&crate::parser::WasmItem],
name: &str,
) -> Result<()> {
println!();
println!(
"{}",
format!(" Why is '{}' in the binary? ", name)
.bold()
.white()
.on_blue()
);
println!();
println!("{}", "Matching items:".bold());
for item in matching {
let size_str = humansize::format_size(item.size, humansize::BINARY);
println!(" {} {} ({})", "->".green(), item.name.yellow(), size_str);
}
println!();
if paths.is_empty() {
println!("{}", "No retention paths found. This item may be:".bold());
println!(" - Directly exported");
println!(" - Referenced from the start function");
println!(" - Referenced from element/data segments");
println!(" - Part of the root set");
return Ok(());
}
println!("{}", "Retention paths (who keeps this alive):".bold());
println!();
for (i, path) in paths.iter().enumerate() {
if i > 0 {
println!();
}
println!(
" {}",
format!("Path {} to '{}':", i + 1, path.target).cyan()
);
for (j, step) in path.path.iter().enumerate() {
let indent = " ".repeat(j + 1);
let arrow = if j == path.path.len() - 1 {
"└─>".green()
} else {
"├──".white()
};
let relationship = if j < path.path.len() - 1 {
format!(" ({} next)", step.relationship)
} else {
String::new()
};
println!(
"{}{} {}{}",
indent,
arrow,
step.name.yellow(),
relationship.dimmed()
);
}
}
println!();
println!(
"{}",
"Tip: To reduce size, consider removing or replacing the root callers.".dimmed()
);
println!();
Ok(())
}