cli/shells/

report.rs

use super::metadata;
use crate::colors;

pub(super) fn style_dim(value: &str) -> String {
    colors::dim(value)
}

pub(super) fn style_green(value: &str) -> String {
    colors::green(value)
}

pub(super) fn style_yellow(value: &str) -> String {
    colors::yellow(value)
}

pub(super) fn style_bold(value: &str) -> String {
    colors::bold(value)
}

pub(super) fn style_symbol(value: &str) -> String {
    colors::symbol(value)
}

#[derive(Debug, Default)]
pub struct ShellUpgradeReport {
    /// User-facing shell targets that were brought up to date. A target is
    /// counted once even when upgrading it also rewrites a preset source,
    /// rendered template, and bin launcher.
    pub updated_targets: Vec<String>,
    /// Category-level lifecycle identities corresponding to `updated_targets`.
    /// Summary counts use these so discovery and upgrade reporting agree.
    pub updated_categories: Vec<String>,
    pub snapshots_updated: usize,
    pub templates_updated: usize,
    pub links_created: usize,
    pub links_updated: usize,
    pub link_conflicts: usize,
    pub path_changed: bool,
}

pub(super) fn shell_cache_summary_parts(
    report: &shine_core::runtime::ShellCacheReport,
) -> Vec<String> {
    cache_summary_parts(
        report.created.len(),
        report.overwritten.len(),
        report.skipped.len(),
    )
}

fn cache_summary_parts(created: usize, overwritten: usize, skipped: usize) -> Vec<String> {
    let mut parts: Vec<String> = Vec::new();
    if created > 0 {
        parts.push(colors::green(&format_file_action(created, "created")));
    }
    if overwritten > 0 {
        parts.push(colors::green(&format_file_action(overwritten, "updated")));
    }
    if skipped > 0 {
        parts.push(colors::dim(&format_file_action(skipped, "skipped")));
    }
    parts
}

pub(super) fn unlink_report_summary_parts(
    unlink_report: &crate::bin_links::UnlinkReport,
) -> Vec<String> {
    let mut parts: Vec<String> = Vec::new();
    if !unlink_report.removed.is_empty() {
        parts.push(colors::green(&format!(
            "{} removed",
            unlink_report.removed.len()
        )));
    }
    if !unlink_report.skipped.is_empty() {
        parts.push(colors::dim(&format!(
            "{} skipped",
            unlink_report.skipped.len()
        )));
    }
    parts
}

pub(super) fn shell_cache_remove_summary_parts(
    report: &shine_core::runtime::ShellCacheReport,
) -> Vec<String> {
    let mut parts = Vec::new();
    if !report.removed.is_empty() {
        parts.push(colors::green(&format_file_action(
            report.removed.len(),
            "removed",
        )));
    }
    if !report.skipped.is_empty() {
        parts.push(colors::dim(&format_file_action(
            report.skipped.len(),
            "skipped",
        )));
    }
    parts
}

pub(super) fn link_report_summary_parts(link_report: &crate::bin_links::LinkReport) -> Vec<String> {
    let mut parts: Vec<String> = Vec::new();
    if !link_report.created.is_empty() {
        parts.push(colors::green(&format!(
            "{} created",
            link_report.created.len()
        )));
    }
    if !link_report.overwritten.is_empty() {
        parts.push(colors::green(&format!(
            "{} updated",
            link_report.overwritten.len()
        )));
    }
    if !link_report.skipped.is_empty() {
        parts.push(colors::dim(&format!(
            "{} up to date",
            link_report.skipped.len()
        )));
    }
    if !link_report.conflicts.is_empty() {
        parts.push(colors::yellow(&format!(
            "{} conflicts",
            link_report.conflicts.len()
        )));
    }
    if parts.is_empty() {
        parts.push(colors::dim("0 linked"));
    }
    parts
}

#[cfg(test)]
pub(super) fn upgrade_link_report_summary_parts(
    link_report: &crate::bin_links::LinkReport,
    verbose: bool,
) -> Vec<String> {
    let mut parts: Vec<String> = Vec::new();
    if !link_report.created.is_empty() {
        parts.push(colors::green(&format!(
            "{} created",
            link_report.created.len()
        )));
    }
    if !link_report.overwritten.is_empty() {
        parts.push(colors::green(&format!(
            "{} updated",
            link_report.overwritten.len()
        )));
    }
    if verbose && !link_report.skipped.is_empty() {
        parts.push(colors::dim(&format!(
            "{} up to date",
            link_report.skipped.len()
        )));
    }
    if !link_report.conflicts.is_empty() {
        parts.push(colors::yellow(&format!(
            "{} conflicts",
            link_report.conflicts.len()
        )));
    }
    parts
}

fn format_file_action(count: usize, action: &str) -> String {
    let noun = if count == 1 { "file" } else { "files" };
    format!("{count} {noun} {action}")
}

pub async fn handle_list(config: &crate::config::Config) -> anyhow::Result<()> {
    handle_list_with_presets_note(config, true).await
}

#[doc(hidden)]
pub async fn handle_list_with_presets_note(
    config: &crate::config::Config,
    print_presets_note: bool,
) -> anyhow::Result<()> {
    if print_presets_note {
        crate::config::print_presets_note(config);
    }
    let categories = if config.is_external_presets {
        metadata::load_installed_categories(config, None).await?
    } else {
        metadata::load_embedded_categories(None)?
    };

    if categories.is_empty() {
        println!("{}", colors::dim("No shell preset categories found."));
        return Ok(());
    }

    println!("{}\n", colors::bold("Shell Preset Categories"));

    let bun_available = crate::platform::command_exists_on_path("bun");

    for cat in &categories {
        let word = if cat.files.len() == 1 {
            "script"
        } else {
            "scripts"
        };
        println!(
            "  {}  {}",
            cat.name,
            colors::dim(&format!("{} {}", cat.files.len(), word))
        );

        let names: Vec<&str> = cat.files.iter().map(|s| s.command_name.as_str()).collect();
        let max_name = names.iter().map(|s| s.len()).max().unwrap_or(0);
        let gap = 4;
        let desc_col = max_name + gap;
        let continuation_indent = " ".repeat(4 + desc_col);

        for (script, name) in cat.files.iter().zip(names.iter()) {
            let padding = " ".repeat(desc_col - name.len());
            match script.description.as_slice() {
                [] => println!("    {name}"),
                [first, rest @ ..] => {
                    println!("    {name}{padding}{first}");
                    for line in rest {
                        if line.is_empty() {
                            println!();
                        } else {
                            println!("{continuation_indent}{line}");
                        }
                    }
                }
            }
            if script.runtime == crate::bin_links::LinkRuntime::Bun {
                let status = if bun_available {
                    colors::green("available")
                } else {
                    colors::yellow("not found on PATH")
                };
                println!(
                    "{continuation_indent}{} {status}",
                    colors::dim("runtime: bun ·")
                );
            }
            println!();
        }
    }

    println!(
        "{}",
        colors::dim("Run `shine install shell/<CATEGORY>` to install a specific category.")
    );
    println!(
        "{}",
        colors::dim("Run `shine shell install` to install all.")
    );
    println!();
    println!(
        "{}",
        colors::dim(
            "After installation, commands are available directly by name (e.g. `setproxy`)."
        )
    );

    Ok(())
}

pub async fn handle_info(config: &crate::config::Config, target: &str) -> anyhow::Result<()> {
    use anyhow::bail;

    crate::config::print_presets_note(config);
    let categories = metadata::load_active_categories(config, None).await?;
    let target = target.trim();
    if target.is_empty() {
        bail!("shell info target must not be empty");
    }

    let (category, files) = if let Some(category) = categories.iter().find(|cat| cat.name == target)
    {
        (category, category.files.iter().collect::<Vec<_>>())
    } else if let Some((category_name, command_name)) = target.split_once('/') {
        let Some(category) = categories.iter().find(|cat| cat.name == category_name) else {
            bail!("shell preset category not found: {category_name}");
        };
        let Some(file) = category
            .files
            .iter()
            .find(|file| file.command_name == command_name)
        else {
            bail!("shell preset command not found: {target}");
        };
        (category, vec![file])
    } else {
        let matches = categories
            .iter()
            .flat_map(|category| {
                category
                    .files
                    .iter()
                    .filter(move |file| file.command_name == target)
                    .map(move |file| (category, file))
            })
            .collect::<Vec<_>>();
        match matches.as_slice() {
            [] => bail!(
                "shell preset target not found: {target}\n\nRun `shine shell list` to see available presets."
            ),
            [(category, file)] => (*category, vec![*file]),
            _ => {
                let choices = matches
                    .iter()
                    .map(|(category, file)| format!("{}/{}", category.name, file.command_name))
                    .collect::<Vec<_>>()
                    .join(", ");
                bail!("ambiguous shell preset target `{target}`; use one of: {choices}");
            }
        }
    };

    let rows = crate::status::build_shell_rows(config).await?;
    let selected_command = (files.len() == 1).then(|| files[0].command_name.clone());
    println!("{}", colors::bold(&category.name));
    if let Some(description) = &category.description {
        println!("  {}", colors::dim(description));
    }

    let bun_available = crate::platform::command_exists_on_path("bun");
    let mut any_installed = false;
    for file in files {
        let label = format!("{}/{}", category.name, file.command_name);
        let row = rows.iter().find(|row| row.label == label);
        any_installed |= row.is_some_and(|row| row.status_text != "not installed");
        println!();
        println!("  {}", colors::bold(&file.command_name));
        println!(
            "    {:<12} shell/{}/{}",
            "Source",
            category.name,
            file.source_rel.display()
        );
        let runtime = match file.runtime {
            crate::bin_links::LinkRuntime::Native => "native".to_string(),
            crate::bin_links::LinkRuntime::Bun if bun_available => "bun (available)".to_string(),
            crate::bin_links::LinkRuntime::Bun => "bun (not found on PATH)".to_string(),
        };
        println!("    {:<12} {runtime}", "Runtime");
        println!(
            "    {:<12} {}",
            "Transforms",
            if file.transforms.is_empty() {
                "none".to_string()
            } else {
                file.transforms.join(", ")
            }
        );
        println!(
            "    {:<12} {}",
            "Environment",
            if file.env.is_empty() {
                "none".to_string()
            } else {
                file.env
                    .iter()
                    .map(crate::env::EnvVarSpec::to_with_arg)
                    .collect::<Vec<_>>()
                    .join(", ")
            }
        );
        println!(
            "    {:<12} {}",
            "Status",
            row.map_or("not installed", |row| row.status_text)
        );
        for (index, line) in file.description.iter().enumerate() {
            println!(
                "    {:<12} {}",
                if index == 0 { "Description" } else { "" },
                line
            );
        }
    }

    println!();
    if any_installed {
        let repair_target = selected_command.as_ref().map_or_else(
            || format!("shell/{}", category.name),
            |command| format!("shell/{}/{command}", category.name),
        );
        println!(
            "{}",
            colors::dim(&format!(
                "Run `shine install {repair_target} --replace-managed` to repair this target."
            ))
        );
    } else {
        let install_target = selected_command.as_ref().map_or_else(
            || category.name.clone(),
            |command| format!("{}/{command}", category.name),
        );
        println!(
            "{}",
            colors::dim(&format!(
                "Run `shine shell install {install_target}` to install this target."
            ))
        );
    }
    Ok(())
}

#[cfg(test)]
mod info_tests {
    use super::*;

    #[tokio::test]
    async fn embedded_shell_info_accepts_category_command_and_canonical_target() {
        let dir = crate::test_support::make_temp_dir("shine-shell-info").await;
        let config = crate::test_support::test_config(&dir);

        handle_info(&config, "proxy").await.unwrap();
        handle_info(&config, "setproxy").await.unwrap();
        handle_info(&config, "proxy/setproxy").await.unwrap();

        tokio::fs::remove_dir_all(dir).await.unwrap();
    }

    #[tokio::test]
    async fn shell_info_rejects_unknown_and_empty_targets() {
        let dir = crate::test_support::make_temp_dir("shine-shell-info-errors").await;
        let config = crate::test_support::test_config(&dir);

        assert!(handle_info(&config, "").await.is_err());
        assert!(handle_info(&config, "not-a-preset").await.is_err());

        tokio::fs::remove_dir_all(dir).await.unwrap();
    }
}

#[cfg(test)]
mod lifecycle_render_tests {
    use super::*;

    #[test]
    fn shell_lifecycle_summary_parts_keep_legacy_wording() {
        let report = crate::bin_links::LinkReport {
            created: vec!["created".into()],
            overwritten: vec!["updated".into()],
            skipped: vec!["current".into()],
            conflicts: Vec::new(),
        };
        assert_eq!(
            link_report_summary_parts(&report),
            vec!["1 created", "1 updated", "1 up to date"]
        );
        assert_eq!(
            upgrade_link_report_summary_parts(&report, false),
            vec!["1 created", "1 updated"]
        );
    }
}