slimwasm 0.1.0

A WASM size profiler for wasm32-unknown-unknown and wasm32-wasip2 binaries
Documentation
//! Implementation of the `why` command

use crate::analysis::RetainedSizeAnalyzer;
use crate::parser::{parse_wasm, WasmItemKind};
use anyhow::{Context, Result};
use colored::Colorize;
use std::path::Path;

/// Run the why command
pub fn run(path: &Path, name: &str, depth: usize, json: bool) -> Result<()> {
    let parsed = parse_wasm(path).context("Failed to parse WASM file")?;

    // First, check if there are any matching items
    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);

    // Get matching items from analyzer's parsed data
    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!();

    // Show matching items
    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(());
    }

    // Show retention paths
    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(())
}