优化clap库下AUR包管理器yay的CLI自动补全性能

你当前的代码在构建CLI定义阶段就同步执行了package_completion().unwrap()，这会导致：

1. 每次启动程序（包括触发补全时）都会强制运行yay -Slq，而该命令需要遍历大量AUR包，本身耗时极长；
2. 补全候选是预加载的静态列表，无法实时更新，且完全阻塞了补全响应流程。

采用clap官方的clap_complete库实现动态补全，仅在用户按Tab触发补全时才去获取包列表，同时加入缓存优化提升响应速度。

步骤1：添加依赖 #

在Cargo.toml中补充必要依赖：

[dependencies]
clap = { version = "4.0", features = ["derive", "cargo", "completion"] }
clap_complete = "4.0"
tokio = { version = "1.0", features = ["full"] } # 用于异步执行yay命令，避免阻塞Shell

步骤2：重构CLI与补全逻辑 #

核心函数改造 #

将包列表获取改为异步+缓存模式：

use clap::{Command, Arg, ArgAction};
use clap_complete::{generate, shells::Shell};
use std::process;
use std::fs::{self, File};
use std::io::Write;
use std::path::Path;
use std::time::{SystemTime, UNIX_EPOCH};

// 缓存配置：1小时有效期，存储在临时目录
const CACHE_PATH: &str = "/tmp/yay-packages-cache.txt";
const CACHE_TTL: u64 = 3600;

// 读取缓存的包列表（如果未过期）
fn get_cached_packages() -> Option<Vec<String>> {
    let cache_file = Path::new(CACHE_PATH);
    if !cache_file.exists() {
        return None;
    }

    // 检查缓存是否过期
    let meta = fs::metadata(cache_file).ok()?;
    let modified = meta.modified().ok()?;
    let elapsed = modified.duration_since(UNIX_EPOCH).ok()?;
    if elapsed.as_secs() > CACHE_TTL {
        fs::remove_file(cache_file).ok();
        return None;
    }

    // 读取缓存内容
    let content = fs::read_to_string(cache_file).ok()?;
    Some(content.lines().map(|s| s.to_string()).collect())
}

// 将包列表写入缓存
fn save_to_cache(packages: &[String]) -> Result<(), String> {
    let mut file = File::create(CACHE_PATH)
        .map_err(|e| format!("创建缓存文件失败: {}", e))?;
    for pkg in packages {
        writeln!(file, "{}", pkg)
            .map_err(|e| format!("写入缓存失败: {}", e))?;
    }
    Ok(())
}

// 异步从yay获取最新包列表
async fn fetch_latest_packages() -> Result<Vec<String>, String> {
    let output = process::Command::new("yay")
        .arg("-Slq")
        .output()
        .map_err(|e| format!("执行yay失败: {}", e))?;

    if !output.stderr.is_empty() {
        return Err(String::from_utf8_lossy(&output.stderr).to_string());
    }

    let stdout = String::from_utf8_lossy(&output.stdout);
    let mut packages: Vec<String> = stdout.lines().map(|s| s.to_string()).collect();
    
    // 移除yay输出的第一行（根据实际输出调整）
    if !packages.is_empty() {
        packages.remove(0);
    }

    Ok(packages)
}

// 优先用缓存，缓存过期则拉取最新列表
async fn get_package_list() -> Result<Vec<String>, String> {
    if let Some(cached) = get_cached_packages() {
        return Ok(cached);
    }

    let packages = fetch_latest_packages().await?;
    save_to_cache(&packages).ok(); // 忽略缓存保存错误，不影响主流程
    Ok(packages)
}

CLI结构调整 #

添加隐藏的补全子命令，标记需要动态补全的参数：

pub fn build_cli() -> Command {
    Command::new("yay-helper")
        .version("0.0.0")
        .subcommand_required(true)
        .arg_required_else_help(true)
        // 隐藏的内部补全命令，用于输出补全候选
        .subcommand(
            Command::new("complete")
                .about("生成补全候选（内部使用）")
                .hidden(true)
                .arg(Arg::new("type").required(true))
        )
        .subcommand(
            Command::new("query")
                .about("查询包信息")
                .arg(
                    Arg::new("package")
                        .help("要查询的包名")
                        .required(true)
                        .action(ArgAction::Set)
                        .num_args(1..)
                        .autocompletion(true) // 标记该参数需要动态补全
                )
        )
        .subcommand(
            Command::new("install")
                .about("安装包")
                .arg(
                    Arg::new("package")
                        .help("要安装的包名")
                        .required(true)
                        .action(ArgAction::Set)
                        .num_args(1..)
                        .autocompletion(true)
                )
        )
}

主函数处理补全请求 #

#[tokio::main]
async fn main() {
    let matches = build_cli().get_matches();

    match matches.subcommand() {
        Some(("complete", comp_matches)) => {
            let comp_type = comp_matches.get_one::<String>("type").unwrap();
            if comp_type == "packages" {
                match get_package_list().await {
                    Ok(pkgs) => pkgs.iter().for_each(|pkg| println!("{}", pkg)),
                    Err(e) => eprintln!("{}", e),
                }
            }
            return;
        }
        Some(("query", query_matches)) => {
            let packages = query_matches.get_many::<String>("package").unwrap();
            println!("查询包: {:?}", packages);
            // 这里添加实际查询逻辑
        }
        Some(("install", install_matches)) => {
            let packages = install_matches.get_many::<String>("package").unwrap();
            println!("安装包: {:?}", packages);
            // 这里添加实际安装逻辑
        }
        _ => unreachable!("子命令为必填项"),
    }
}

步骤3：生成多Shell补全脚本 #

添加生成补全脚本的子命令，支持bash、zsh、fish、PowerShell：

// 在build_cli()中添加：
.subcommand(
    Command::new("gen-completions")
        .about("生成Shell补全脚本")
        .arg(
            Arg::new("shell")
                .required(true)
                .possible_values(["bash", "zsh", "fish", "powershell"])
        )
)

// 在main函数中处理：
Some(("gen-completions", gen_matches)) => {
    let shell_name = gen_matches.get_one::<String>("shell").unwrap();
    let shell = match shell_name.as_str() {
        "bash" => Shell::Bash,
        "zsh" => Shell::Zsh,
        "fish" => Shell::Fish,
        "powershell" => Shell::PowerShell,
        _ => unreachable!(),
    };
    generate(shell, &mut build_cli(), "yay-helper", &mut std::io::stdout());
}

生成后将脚本放到对应Shell的补全目录：

• Bash: /usr/share/bash-completion/completions/yay-helper
• Zsh: ~/.zsh/completions/_yay-helper
• Fish: ~/.config/fish/completions/yay-helper.fish

1. 延迟执行：仅在用户按Tab触发补全时才会获取包列表，避免程序启动时的无意义耗时；
2. 缓存加速：首次补全后1小时内复用缓存，大幅降低重复调用yay的次数；
3. 异步非阻塞：用tokio异步执行yay命令，不会阻塞Shell主线程；
4. 多Shell支持：通过clap_complete原生支持主流Shell，无需额外第三方库。

内容的提问来源于stack exchange，提问作者DevAles