sniplab 0.3.2

A filesystem-native snippet library and agent-friendly CLI, installed as `snip`
Documentation
use std::fs;
use std::io::{self, IsTerminal};

use serde::Serialize;
use serde_json::json;
use snip::config::{AppConfig, TuiConfig};
use snip::error::{Result, SnipError};
use snip::theme::validate::{self, Level};
use snip::theme::{Appearance, NamedColor, Theme, ThemeColor, ThemeSummary};

use super::output::{print_record, print_records, resolve_color, resolve_output};
use crate::cli::{AppearanceArg, ColorMode, OutputMode, ThemeArgs, ThemeCommand};

#[derive(Serialize)]
struct ListRecord {
    name: String,
    display_name: String,
    appearance: Appearance,
    source: Option<String>,
    builtin: bool,
    active: bool,
    error: Option<String>,
}

pub fn command_theme(args: &ThemeArgs, explicit_output: Option<OutputMode>) -> Result<()> {
    let config = AppConfig::load()?;
    let output = resolve_output(explicit_output, &config);
    match &args.command {
        ThemeCommand::List { appearance } => command_list(*appearance, &config, output),
        ThemeCommand::Show { name } => command_show(name, &config, output),
        ThemeCommand::Check { name } => command_check(name, output),
        ThemeCommand::Path => {
            println!("{}", snip::theme::themes_dir()?.display());
            Ok(())
        }
        ThemeCommand::Export { name, r#as, force } => {
            command_export(name, r#as.as_deref(), *force, output)
        }
        ThemeCommand::Use { name, appearance } => command_use(name, *appearance, &config, output),
    }
}

fn command_list(
    filter: Option<AppearanceArg>,
    config: &AppConfig,
    output: OutputMode,
) -> Result<()> {
    let tui = config.tui.clone().unwrap_or_default();
    let records = snip::theme::list()
        .into_iter()
        .filter(|summary| filter.is_none_or(|filter| appearance(filter) == summary.appearance))
        .map(|summary| list_record(summary, &tui))
        .collect::<Vec<_>>();
    if output != OutputMode::Human {
        return print_records(&records, output);
    }
    let mut current = None;
    for record in records {
        if current != Some(record.appearance) {
            if current.is_some() {
                println!();
            }
            println!("{}:", record.appearance.as_str());
            current = Some(record.appearance);
        }
        let suffix = if let Some(error) = &record.error {
            format!("  (invalid: {error})")
        } else if record.active {
            "  (active)".to_owned()
        } else {
            String::new()
        };
        println!("  {:<20} {:<24}{suffix}", record.name, record.display_name);
    }
    Ok(())
}

fn list_record(summary: ThemeSummary, config: &TuiConfig) -> ListRecord {
    let active_name = match summary.appearance {
        Appearance::Light => config.light_theme.as_deref().unwrap_or("light-default"),
        Appearance::Dark => config.dark_theme.as_deref().unwrap_or("dark-default"),
    };
    ListRecord {
        active: summary.name == active_name,
        name: summary.name,
        display_name: summary.display_name,
        appearance: summary.appearance,
        source: summary.source,
        builtin: summary.builtin,
        error: summary.error,
    }
}

fn command_show(name: &str, config: &AppConfig, output: OutputMode) -> Result<()> {
    let theme = snip::theme::load(name)?;
    if output != OutputMode::Human {
        return print_record(&theme, output);
    }
    println!("{} ({})", theme.display_name, theme.name);
    println!("appearance  {}", theme.appearance.as_str());
    let color = resolve_color(None, config);
    let swatches =
        color == ColorMode::Always || color == ColorMode::Auto && io::stdout().is_terminal();
    for (role, value) in ui_colors(&theme) {
        if swatches {
            print!("{}  \x1b[0m ", background_escape(value));
        }
        println!("{role:<16} {value}");
    }
    Ok(())
}

fn command_check(name: &str, output: OutputMode) -> Result<()> {
    let theme = snip::theme::load(name)?;
    let checks = validate::check(&theme);
    let ok = !checks.iter().any(|check| check.level == Level::Fail);
    if output == OutputMode::Human {
        println!("theme: {name}");
        for check in &checks {
            println!(
                "  {:<5} {:<24} {}",
                level_name(check.level),
                check.id,
                check.detail
            );
        }
    } else {
        print_record(&json!({ "name": name, "ok": ok, "checks": checks }), output)?;
    }
    if !ok {
        std::process::exit(1);
    }
    Ok(())
}

fn command_use(
    name: &str,
    slot: Option<AppearanceArg>,
    original: &AppConfig,
    output: OutputMode,
) -> Result<()> {
    let theme = snip::theme::load(name)?;
    let selected = slot.map(appearance).unwrap_or(theme.appearance);
    if slot.is_some() && selected != theme.appearance {
        eprintln!(
            "warning: theme {name} is a {} theme in the {} slot",
            theme.appearance.as_str(),
            selected.as_str()
        );
    }
    let mut config = original.clone();
    let tui = config.tui.get_or_insert_with(TuiConfig::default);
    match selected {
        Appearance::Light => tui.light_theme = Some(name.to_owned()),
        Appearance::Dark => tui.dark_theme = Some(name.to_owned()),
    }
    config.save()?;
    if output == OutputMode::Human {
        println!("theme: {name}");
    } else {
        print_record(
            &json!({ "updated": "theme", "name": name, "appearance": selected }),
            output,
        )?;
    }
    Ok(())
}

fn command_export(
    name: &str,
    save_as: Option<&str>,
    force: bool,
    output: OutputMode,
) -> Result<()> {
    let mut theme = snip::theme::load(name)?;
    let new_name = save_as
        .map(str::to_owned)
        .unwrap_or_else(|| format!("{name}-custom"));
    snip::theme::validate_theme_name(&new_name)?;
    theme.name = new_name.clone();
    let directory = snip::theme::themes_dir()?;
    let path = directory.join(format!("{new_name}.toml"));
    if path.exists() && !force {
        return Err(SnipError::validation(format!(
            "{} already exists; pass --force to overwrite",
            path.display()
        )));
    }
    fs::create_dir_all(&directory).map_err(|error| {
        SnipError::io(format!("cannot create {}: {error}", directory.display()))
    })?;
    fs::write(&path, toml::to_string_pretty(&theme)?)
        .map_err(|error| SnipError::io(format!("cannot write {}: {error}", path.display())))?;
    if output == OutputMode::Human {
        println!("exported: {}", path.display());
    } else {
        print_record(&json!({ "name": new_name, "path": path }), output)?;
    }
    Ok(())
}

fn appearance(value: AppearanceArg) -> Appearance {
    match value {
        AppearanceArg::Light => Appearance::Light,
        AppearanceArg::Dark => Appearance::Dark,
    }
}

fn level_name(level: Level) -> &'static str {
    match level {
        Level::Ok => "ok",
        Level::Warn => "warn",
        Level::Fail => "fail",
    }
}

fn ui_colors(theme: &Theme) -> [(&'static str, ThemeColor); 18] {
    let ui = &theme.ui;
    [
        ("background", ui.background),
        ("foreground", ui.foreground),
        ("accent", ui.accent),
        ("accent_alt", ui.accent_alt),
        ("border", ui.border),
        ("muted", ui.muted),
        ("selection_bg", ui.selection_bg),
        ("selection_fg", ui.selection_fg),
        ("retained_bg", ui.retained_bg),
        ("pill_primary", ui.pill_primary),
        ("pill_secondary", ui.pill_secondary),
        ("bar_bg", ui.bar_bg),
        ("bar_fg", ui.bar_fg),
        ("tag", ui.tag),
        ("rule", ui.rule),
        ("success", ui.success),
        ("warning", ui.warning),
        ("error", ui.error),
    ]
}

fn background_escape(color: ThemeColor) -> String {
    match color {
        ThemeColor::Rgb(red, green, blue) => format!("\x1b[48;2;{red};{green};{blue}m"),
        ThemeColor::Indexed(index) => format!("\x1b[48;5;{index}m"),
        ThemeColor::Named(named) => format!("\x1b[{}m", named_background_code(named)),
        ThemeColor::Terminal => "\x1b[49m".to_owned(),
    }
}

fn named_background_code(color: NamedColor) -> u8 {
    match color {
        NamedColor::Black => 40,
        NamedColor::Red => 41,
        NamedColor::Green => 42,
        NamedColor::Yellow => 43,
        NamedColor::Blue => 44,
        NamedColor::Magenta => 45,
        NamedColor::Cyan => 46,
        NamedColor::White => 47,
        NamedColor::BrightBlack => 100,
        NamedColor::BrightRed => 101,
        NamedColor::BrightGreen => 102,
        NamedColor::BrightYellow => 103,
        NamedColor::BrightBlue => 104,
        NamedColor::BrightMagenta => 105,
        NamedColor::BrightCyan => 106,
        NamedColor::BrightWhite => 107,
    }
}