gitflow-cli 2.1.0

跨平台 Git 工程化工作流编排框架:统一封装 GitHub / GitLab / GitCode 三大平台,配合 AI Agent Skills,覆盖从需求到发布的完整工程循环。
//! `gf update` 子命令实现。
//!
//! 从 GitHub Releases 检查并更新 gf binary 到最新版本。
//! 版本选择逻辑独立为纯函数,便于单测覆盖;
//! 更新流程通过注入的版本获取函数支持无网络单测。

use clap::{ArgAction, Args};
use is_terminal::IsTerminal;
use semver::Version;

/// GitHub 仓库 owner。
pub(crate) const REPO_OWNER: &str = "byx-darwin";
/// GitHub 仓库名。
pub(crate) const REPO_NAME: &str = "gitflow-cli";
/// binary 名称。
pub(crate) const BIN_NAME: &str = "gf";

/// Ed25519 public key for verifying release signatures.
///
/// Generated by `release-signer generate-key`.
/// When the `skip-verify` feature is enabled, this key is not compiled in.
#[cfg(not(feature = "skip-verify"))]
const VERIFYING_KEY: [u8; 32] = [
    115, 185, 47, 145, 23, 237, 255, 233, 186, 137, 155, 236, 246, 152, 123, 129, 154, 24, 245,
    229, 138, 7, 69, 74, 76, 175, 104, 136, 203, 153, 193, 194,
];

/// 解析 semver 版本字符串(容忍前导 `v`)。
fn parse_version(s: &str) -> Option<Version> {
    Version::parse(s.trim_start_matches('v')).ok()
}

/// 是否为预发布版本(含 `-alpha`/`-beta`/`-rc` 等 pre 标识)。
fn is_prerelease(v: &Version) -> bool {
    !v.pre.is_empty()
}

/// 从候选版本中选择目标版本:返回大于 `current` 的最高版本。
///
/// `include_prerelease` 为 `false` 时排除预发布版本(稳定版优先)。
fn select_target_version<'a>(
    candidates: impl Iterator<Item = &'a str>,
    current: &Version,
    include_prerelease: bool,
) -> Option<String> {
    candidates
        .filter_map(parse_version)
        .filter(|v| *v > *current && (include_prerelease || !is_prerelease(v)))
        .max()
        .map(|v| v.to_string())
}

/// 当前安装的 gf 版本(编译期注入)。
fn current_version() -> String {
    crate::built_info::PKG_VERSION.to_string()
}

/// 当前平台目标三元组(如 `x86_64-apple-darwin`)。
fn target_triple() -> String {
    self_update::get_target().to_string()
}

/// `gf update` 参数。
#[derive(Debug, Args)]
pub struct UpdateArgs {
    /// 包含预发布版本(alpha/beta/rc),默认仅稳定版
    #[arg(long, action = ArgAction::SetTrue)]
    pub pre: bool,

    /// 仅检查是否有新版本,不执行更新
    #[arg(long, action = ArgAction::SetTrue)]
    pub check: bool,

    /// 跳过确认提示,直接更新
    #[arg(short = 'y', long = "yes", action = ArgAction::SetTrue)]
    pub yes: bool,
}

/// 处理 `gf update` 命令。
///
/// # Errors
///
/// - 无法获取 GitHub release 列表(网络错误)
/// - 当前版本号无法解析
/// - `self_update` 下载/替换 binary 失败
pub fn handle_update(args: &UpdateArgs) -> miette::Result<()> {
    handle_update_with(args, fetch_release_versions)
}

/// `gf update` 核心逻辑(注入版本获取函数,便于单测覆盖网络路径)。
fn handle_update_with(
    args: &UpdateArgs,
    fetch_versions: impl Fn(&str) -> miette::Result<Vec<String>>,
) -> miette::Result<()> {
    let current = current_version();
    let current_v =
        parse_version(&current).ok_or_else(|| miette::miette!("当前版本号无法解析: {current}"))?;
    let target = target_triple();

    let versions = fetch_versions(&target)?;
    let Some(latest) =
        select_target_version(versions.iter().map(String::as_str), &current_v, args.pre)
    else {
        println!("✅ 已是最新版本 v{current}");
        return Ok(());
    };

    if args.check {
        println!("当前版本: v{current}");
        println!("最新版本: v{latest}");
        return Ok(());
    }

    if !args.yes && !crate::commands::skills::confirm(&format!("是否更新到 v{latest}?"), true)?
    {
        println!("已取消更新");
        return Ok(());
    }

    let mut updater = self_update::backends::github::Update::configure();
    let builder = updater
        .repo_owner(REPO_OWNER)
        .repo_name(REPO_NAME)
        .bin_name(BIN_NAME)
        .current_version(&current)
        .target_version_tag(&format!("v{latest}"))
        .target(&target)
        .show_download_progress(true)
        .show_output(true)
        .no_confirm(true);

    #[cfg(not(feature = "skip-verify"))]
    {
        builder.verifying_keys(vec![VERIFYING_KEY]);
    }

    let status = builder
        .build()
        .map_err(|e| miette::miette!("配置更新器失败: {e}"))?
        .update()
        .map_err(|e| miette::miette!("更新失败: {e}"))?;

    println!("✅ gf 已更新到 v{}", status.version());

    prompt_update_skills()?;
    Ok(())
}

/// 从 GitHub Releases 获取适配当前平台的可用版本列表。
///
/// # Errors
///
/// - 网络请求失败
/// - 仓库无 release
fn fetch_release_versions(target: &str) -> miette::Result<Vec<String>> {
    let releases = self_update::backends::github::ReleaseList::configure()
        .repo_owner(REPO_OWNER)
        .repo_name(REPO_NAME)
        .with_target(target)
        .build()
        .map_err(|e| miette::miette!("配置 release 查询失败: {e}"))?
        .fetch()
        .map_err(|e| miette::miette!("获取 release 列表失败: {e}"))?;
    Ok(releases.into_iter().map(|r| r.version).collect())
}

/// 更新 binary 后提示是否同步更新全局 skills。
fn prompt_update_skills() -> miette::Result<()> {
    if !std::io::stderr().is_terminal() {
        println!("ℹ️ 非交互模式,已跳过 skills 同步。可运行 `gf skills update -g` 手动更新。");
        return Ok(());
    }
    if crate::commands::skills::confirm("是否同时更新全局 skills?", true)? {
        let args = crate::commands::skills::SkillsUpdateArgs {
            global: true,
            agent: None,
            custom_path: None,
        };
        crate::commands::skills::update_skills(&args)?;
    }
    Ok(())
}

#[cfg(test)]
#[allow(
    clippy::expect_used,
    clippy::unwrap_used,
    clippy::panic,
    reason = "允许在测试中使用 expect/unwrap/panic"
)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_version_stable() {
        assert_eq!(parse_version("1.0.0"), Some(Version::new(1, 0, 0)));
    }

    #[test]
    fn test_parse_version_strips_leading_v() {
        assert_eq!(parse_version("v1.2.3"), Some(Version::new(1, 2, 3)));
    }

    #[test]
    fn test_parse_version_prerelease() {
        let v = parse_version("1.1.0-rc.1").expect("parse rc");
        assert!(v.pre.to_string().contains("rc"));
    }

    #[test]
    fn test_parse_version_invalid() {
        assert_eq!(parse_version("not-a-version"), None);
        assert_eq!(parse_version(""), None);
    }

    #[test]
    fn test_is_prerelease_rc_is_prerelease() {
        assert!(is_prerelease(&Version::parse("1.1.0-rc.1").expect("rc")));
    }

    #[test]
    fn test_is_prerelease_stable_is_not() {
        assert!(!is_prerelease(&Version::new(1, 1, 0)));
    }

    #[test]
    fn test_select_target_version_ignores_prerelease_by_default() {
        let candidates = ["1.0.1", "1.1.0-rc.1", "1.1.0"];
        let current = Version::new(1, 0, 0);
        assert_eq!(
            select_target_version(candidates.into_iter(), &current, false).as_deref(),
            Some("1.1.0")
        );
    }

    #[test]
    fn test_select_target_version_includes_prerelease_with_flag() {
        let current = Version::new(1, 0, 0);
        // 稳定版更高时仍选稳定版
        let candidates = ["1.1.0-rc.1", "1.1.0"];
        assert_eq!(
            select_target_version(candidates.into_iter(), &current, true).as_deref(),
            Some("1.1.0")
        );
        // 仅预发布更高时,--pre 选中预发布
        let candidates = ["1.1.0-rc.1", "1.0.5"];
        assert_eq!(
            select_target_version(candidates.into_iter(), &current, true).as_deref(),
            Some("1.1.0-rc.1")
        );
    }

    #[test]
    fn test_select_target_version_none_when_up_to_date() {
        let candidates = ["0.9.0", "1.0.0"];
        let current = Version::new(1, 0, 0);
        assert_eq!(
            select_target_version(candidates.into_iter(), &current, false),
            None
        );
    }

    #[test]
    fn test_select_target_version_skips_invalid() {
        let candidates = ["not-a-version", "", "1.0.1"];
        let current = Version::new(1, 0, 0);
        assert_eq!(
            select_target_version(candidates.into_iter(), &current, false).as_deref(),
            Some("1.0.1")
        );
    }

    use clap::{Parser, Subcommand};

    #[derive(Debug, Parser)]
    struct TestCli {
        #[command(subcommand)]
        cmd: TestCmd,
    }

    #[derive(Debug, Subcommand)]
    enum TestCmd {
        Update(UpdateArgs),
    }

    #[test]
    fn test_update_args_parse_flags() {
        let cli = TestCli::parse_from(["test", "update", "--check", "--pre", "--yes"]);
        let TestCmd::Update(args) = cli.cmd;
        assert!(args.check);
        assert!(args.pre);
        assert!(args.yes);
    }

    #[test]
    fn test_update_up_to_date_when_no_newer() {
        let args = UpdateArgs {
            pre: false,
            check: false,
            yes: true,
        };
        let versions = vec![current_version()];
        let result = handle_update_with(&args, |_| Ok(versions.clone()));
        assert!(result.is_ok());
    }

    #[test]
    fn test_update_check_reports_latest_without_updating() {
        let args = UpdateArgs {
            pre: false,
            check: true,
            yes: false,
        };
        let versions = vec!["9.9.9".to_string()];
        let result = handle_update_with(&args, |_| Ok(versions.clone()));
        assert!(result.is_ok());
    }

    #[test]
    #[cfg(not(feature = "skip-verify"))]
    fn test_verifying_key_is_32_bytes() {
        assert_eq!(VERIFYING_KEY.len(), 32);
        // Placeholder key has last byte = 1, real key will differ
        assert!(VERIFYING_KEY.iter().any(|&b| b != 0));
    }
}