#![allow(
clippy::disallowed_methods,
clippy::disallowed_types,
reason = "Skills command runs synchronously before the tokio runtime is constructed"
)]
use std::path::PathBuf;
include!(concat!(env!("OUT_DIR"), "/skills_manifest.rs"));
use clap::{ArgAction, Args, Subcommand, ValueEnum};
use gitflow_cli_core::AuthChecker;
use is_terminal::IsTerminal;
use crate::error_reporter::read_co_contribution_flag;
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub enum AgentPlatform {
Claude,
Codex,
OpenCode,
Gemini,
Copilot,
}
impl AgentPlatform {
#[must_use]
pub fn skills_dir_name(self) -> &'static str {
match self {
AgentPlatform::Claude => ".claude/skills",
AgentPlatform::Codex => ".codex/skills",
AgentPlatform::OpenCode => ".opencode/skills",
AgentPlatform::Gemini => ".gemini/skills",
AgentPlatform::Copilot => ".copilot/skills",
}
}
#[must_use]
pub fn hooks_dir_name(self) -> &'static str {
match self {
AgentPlatform::Claude => ".claude/hooks",
AgentPlatform::Codex => ".codex/hooks",
AgentPlatform::OpenCode => ".opencode/hooks",
AgentPlatform::Gemini => ".gemini/hooks",
AgentPlatform::Copilot => ".copilot/hooks",
}
}
#[must_use]
pub fn settings_file_path(self) -> &'static str {
match self {
AgentPlatform::Claude => ".claude/settings.json",
AgentPlatform::Codex => ".codex/settings.json",
AgentPlatform::OpenCode => ".opencode/settings.json",
AgentPlatform::Gemini => ".gemini/settings.json",
AgentPlatform::Copilot => ".copilot/settings.json",
}
}
#[must_use]
pub const fn supports_hooks(self) -> bool {
matches!(self, AgentPlatform::Claude | AgentPlatform::Codex)
}
#[must_use]
pub fn detect() -> Self {
AgentPlatform::Claude
}
}
#[derive(Debug, Subcommand)]
pub enum SkillsCommand {
Install(InstallArgs),
List(ListArgs),
Uninstall(UninstallArgs),
}
#[derive(Debug, Args)]
pub struct InstallArgs {
#[arg(short = 'g', long, action = ArgAction::SetTrue)]
pub global: bool,
#[arg(long, value_enum)]
pub agent: Option<AgentPlatform>,
#[arg(long = "path")]
pub custom_path: Option<String>,
#[arg(short = 'f', long, action = ArgAction::SetTrue)]
pub force: bool,
#[arg(long = "report-bug", default_value_t = true, action = ArgAction::Set)]
pub report_bug: bool,
}
#[derive(Debug, Args)]
pub struct ListArgs {
#[arg(short = 'g', long, action = ArgAction::SetTrue)]
pub global: bool,
#[arg(long, value_enum)]
pub agent: Option<AgentPlatform>,
#[arg(long = "path")]
pub custom_path: Option<String>,
}
#[derive(Debug, Args)]
pub struct UninstallArgs {
#[arg(short = 'g', long, action = ArgAction::SetTrue)]
pub global: bool,
#[arg(long, value_enum)]
pub agent: Option<AgentPlatform>,
#[arg(long = "path")]
pub custom_path: Option<String>,
}
fn resolve_target_dir(
global: bool,
agent: Option<AgentPlatform>,
custom_path: Option<&str>,
) -> miette::Result<PathBuf> {
if let Some(p) = custom_path {
return Ok(PathBuf::from(p));
}
let platform = agent.unwrap_or_else(AgentPlatform::detect);
if global {
let home = dirs::home_dir().ok_or_else(|| miette::miette!("无法确定 HOME 目录"))?;
Ok(home.join(platform.skills_dir_name()))
} else {
let repo_root = git_repo_root()?;
Ok(resolve_project_target(&repo_root, platform))
}
}
fn resolve_project_target(repo_root: &std::path::Path, agent: AgentPlatform) -> PathBuf {
repo_root.join(agent.skills_dir_name())
}
fn skills_source_dir() -> PathBuf {
if let Ok(exe) = std::env::current_exe()
&& let Some(exe_dir) = exe.parent()
{
let candidate = exe_dir.join("skills");
if candidate.exists() {
return candidate;
}
if let Some(parent) = exe_dir.parent() {
let candidate = parent.join("skills");
if candidate.exists() {
return candidate;
}
}
}
PathBuf::from("skills")
}
pub fn handle(command: &SkillsCommand) -> miette::Result<()> {
match command {
SkillsCommand::Install(args) => install_skills(args),
SkillsCommand::List(args) => list_skills(args),
SkillsCommand::Uninstall(args) => uninstall_skills(args),
}
}
fn install_skills(args: &InstallArgs) -> miette::Result<()> {
let platform = args.agent.unwrap_or_else(AgentPlatform::detect);
let target = resolve_target_dir(args.global, Some(platform), args.custom_path.as_deref())?;
let source = skills_source_dir();
let has_source = source.exists();
let has_bundled = !SKILLS.is_empty();
if has_source {
std::fs::create_dir_all(&target)
.map_err(|e| miette::miette!("无法创建目标目录 {}: {e}", target.display()))?;
let level = if args.global { "全局" } else { "项目级" };
println!("目标: {} ({level})", target.display());
let mut installed = 0u32;
let mut skipped = 0u32;
let mut overwritten = 0u32;
for entry in std::fs::read_dir(&source)
.map_err(|e| miette::miette!("无法读取 skills 源目录 {}: {e}", source.display()))?
{
let entry = entry.map_err(|e| miette::miette!("读取目录项失败: {e}"))?;
let name = entry.file_name();
let name_str = name.to_string_lossy();
if !name_str.starts_with("gitflow-") {
continue;
}
let dest = target.join(&name);
if dest.exists() {
if args.force {
std::fs::remove_dir_all(&dest)
.map_err(|e| miette::miette!("无法删除旧版本 {}: {e}", dest.display()))?;
copy_dir_all(&entry.path(), &dest)
.map_err(|e| miette::miette!("复制 {} 失败: {e}", name_str))?;
println!("♻ 已覆盖: {name_str}");
overwritten += 1;
} else {
eprintln!("⚠ 跳过已存在: {name_str}");
skipped += 1;
}
continue;
}
copy_dir_all(&entry.path(), &dest)
.map_err(|e| miette::miette!("复制 {} 失败: {e}", name_str))?;
println!("✅ 已安装: {name_str}");
installed += 1;
}
println!();
println!("安装完成: 新增 {installed} 个,覆盖 {overwritten} 个,跳过 {skipped} 个");
} else if has_bundled {
install_skills_bundled(&target, args)?;
} else {
println!("⚠ Skills 源目录未找到,且 binary 未内嵌 skills 数据");
println!(" 请从源码目录运行,或手动指定 --source <skills 目录路径>");
}
if args.report_bug {
if platform.supports_hooks() {
install_hook(args.global, args.force, platform)?;
} else {
let name = platform.to_possible_value().map_or_else(
|| format!("{platform:?}").to_lowercase(),
|pv| pv.get_name().to_owned(),
);
println!("⚠ Agent {name} 不支持 Stop hook,已跳过 hook 安装");
}
}
try_enable_co_contribution(platform)?;
Ok(())
}
fn install_skills_bundled(target: &std::path::Path, args: &InstallArgs) -> miette::Result<()> {
std::fs::create_dir_all(target).map_err(|e| miette::miette!("无法创建目标目录: {e}"))?;
println!(
"目标: {} ({})",
target.display(),
if args.global { "全局" } else { "项目级" }
);
println!("使用内嵌 skills 数据({} 个文件)", SKILLS.len());
let mut skill_dirs: std::collections::HashMap<&str, Vec<(&str, &[u8])>> =
std::collections::HashMap::new();
for (path, data) in SKILLS {
let parts: Vec<&str> = path.split('/').collect();
if parts.len() >= 2
&& parts.first().is_some_and(|f| f.starts_with("gitflow-"))
&& let Some(&first) = parts.first()
{
let relative = &path[first.len() + 1..];
skill_dirs.entry(first).or_default().push((relative, *data));
}
}
let mut installed = 0u32;
let mut skipped = 0u32;
let mut overwritten = 0u32;
for (skill_name, files) in &skill_dirs {
let dest = target.join(skill_name);
install_single_skill_bundled(
&dest,
files,
args,
&mut installed,
&mut skipped,
&mut overwritten,
)?;
}
println!();
println!("安装完成: 新增 {installed} 个,覆盖 {overwritten} 个,跳过 {skipped} 个");
Ok(())
}
fn install_single_skill_bundled(
dest: &std::path::Path,
files: &[(&str, &[u8])],
args: &InstallArgs,
installed: &mut u32,
skipped: &mut u32,
overwritten: &mut u32,
) -> miette::Result<()> {
let is_overwrite = dest.exists();
if is_overwrite {
if args.force {
std::fs::remove_dir_all(dest).map_err(|e| miette::miette!("无法删除: {e}"))?;
} else {
eprintln!("⚠ 跳过已存在: {}", dest.display());
*skipped += 1;
return Ok(());
}
}
for (rel_path, data) in files {
let file_path = dest.join(rel_path);
if let Some(parent) = file_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| miette::miette!("创建目录失败: {e}"))?;
}
std::fs::write(&file_path, data).map_err(|e| miette::miette!("写入失败: {e}"))?;
}
if is_overwrite && args.force {
println!("♻ 已覆盖: {}", dest.display());
*overwritten += 1;
} else {
println!("✅ 已安装: {}", dest.display());
*installed += 1;
}
Ok(())
}
fn resolve_hook_paths(
global: bool,
platform: AgentPlatform,
) -> miette::Result<(PathBuf, PathBuf, String)> {
if global {
let home = dirs::home_dir().ok_or_else(|| miette::miette!("无法确定 HOME 目录"))?;
Ok(resolve_global_hook_paths(&home, platform))
} else {
let repo = git_repo_root()?;
Ok(resolve_project_hook_paths(&repo, platform))
}
}
fn resolve_global_hook_paths(
home: &std::path::Path,
platform: AgentPlatform,
) -> (PathBuf, PathBuf, String) {
let hooks_dir = platform.hooks_dir_name();
let settings_file = platform.settings_file_path();
let cmd = format!("bash ~/{hooks_dir}/auto-report-bug.sh");
(home.join(hooks_dir), home.join(settings_file), cmd)
}
fn resolve_project_hook_paths(
repo: &std::path::Path,
platform: AgentPlatform,
) -> (PathBuf, PathBuf, String) {
let hooks_dir = platform.hooks_dir_name();
let settings_file = platform.settings_file_path();
let cmd = format!(
"bash \"$(git rev-parse --show-toplevel 2>/dev/null || \
pwd)/{hooks_dir}/auto-report-bug.sh\""
);
(repo.join(hooks_dir), repo.join(settings_file), cmd)
}
fn install_hook(global: bool, force: bool, platform: AgentPlatform) -> miette::Result<()> {
let hook_script = include_bytes!("../../hooks/auto-report-bug.sh");
let (hook_dir, settings_path, cmd) = resolve_hook_paths(global, platform)?;
std::fs::create_dir_all(&hook_dir).map_err(|e| miette::miette!("无法创建 hook 目录: {e}"))?;
let hook_path = hook_dir.join("auto-report-bug.sh");
if !hook_path.exists() || force {
std::fs::write(&hook_path, hook_script)
.map_err(|e| miette::miette!("无法写入 hook 脚本: {e}"))?;
}
let settings_json = if settings_path.exists() {
let content = std::fs::read_to_string(&settings_path)
.map_err(|e| miette::miette!("无法读取配置: {e}"))?;
serde_json::from_str::<serde_json::Value>(&content)
.map_err(|e| miette::miette!("无法解析配置: {e}"))?
} else {
serde_json::json!({})
};
let new_settings = merge_stop_hook(settings_json, &cmd);
let formatted =
serde_json::to_string_pretty(&new_settings).map_err(|e| miette::miette!("JSON: {e}"))?;
std::fs::write(&settings_path, formatted).map_err(|e| miette::miette!("写入配置: {e}"))?;
println!(
"✅ Hook 已安装 ({})",
if global { "全局" } else { "项目级" }
);
Ok(())
}
fn merge_stop_hook(mut json: serde_json::Value, cmd: &str) -> serde_json::Value {
let hook = serde_json::json!({
"matcher": "gitflow",
"hooks": [
{
"type": "command",
"command": cmd
}
]
});
if let serde_json::Value::Object(obj) = &mut json {
let hooks = obj
.entry("hooks")
.or_insert(serde_json::json!({"Stop": []}));
if let serde_json::Value::Object(h) = hooks {
let stops = h.entry("Stop").or_insert(serde_json::json!([]));
if let serde_json::Value::Array(arr) = stops {
if let Some(existing) = arr
.iter_mut()
.find(|v| v.get("matcher").and_then(|m| m.as_str()) == Some("gitflow"))
{
*existing = hook;
} else {
arr.push(hook);
}
}
}
} else {
json = serde_json::json!({
"hooks": {
"Stop": [hook]
}
});
}
json
}
fn git_repo_root() -> miette::Result<std::path::PathBuf> {
let output = std::process::Command::new("git")
.args(["rev-parse", "--show-toplevel"])
.output();
match output {
Ok(out) if out.status.success() => Ok(std::path::PathBuf::from(
String::from_utf8_lossy(&out.stdout).trim(),
)),
_ => std::env::current_dir().map_err(|e| miette::miette!("无法获取当前目录: {e}")),
}
}
fn list_skills(args: &ListArgs) -> miette::Result<()> {
let target = resolve_target_dir(args.global, args.agent, args.custom_path.as_deref())?;
if !target.exists() {
println!("(未安装任何 skills)");
println!("目录: {}", target.display());
return Ok(());
}
println!("目录: {}", target.display());
println!();
let mut found = 0u32;
for entry in std::fs::read_dir(&target)
.map_err(|e| miette::miette!("读取目录失败 {}: {e}", target.display()))?
{
let entry = entry.map_err(|e| miette::miette!("读取目录项失败: {e}"))?;
let name_str = entry.file_name().to_string_lossy().into_owned();
if name_str.starts_with("gitflow-") {
println!(" {name_str}");
found += 1;
}
}
if found == 0 {
println!("(未安装任何 gitflow skills)");
} else {
println!();
println!("共 {found} 个 skills");
}
Ok(())
}
fn uninstall_skills(args: &UninstallArgs) -> miette::Result<()> {
let platform = args.agent.unwrap_or_else(AgentPlatform::detect);
let target = resolve_target_dir(args.global, Some(platform), args.custom_path.as_deref())?;
if !target.exists() {
println!("(未安装任何 skills)");
println!("目录: {}", target.display());
return Ok(());
}
println!("目录: {}", target.display());
println!();
let mut removed = 0u32;
for entry in std::fs::read_dir(&target)
.map_err(|e| miette::miette!("读取目录失败 {}: {e}", target.display()))?
{
let entry = entry.map_err(|e| miette::miette!("读取目录项失败: {e}"))?;
let name_str = entry.file_name().to_string_lossy().into_owned();
if name_str.starts_with("gitflow-") {
let path = entry.path();
if path.is_dir() {
std::fs::remove_dir_all(&path)
.map_err(|e| miette::miette!("删除 {} 失败: {e}", path.display()))?;
} else {
std::fs::remove_file(&path)
.map_err(|e| miette::miette!("删除 {} 失败: {e}", path.display()))?;
}
println!("✅ 已卸载: {name_str}");
removed += 1;
}
}
if removed == 0 {
println!("(未安装任何 gitflow skills)");
} else {
println!();
println!("已卸载 {removed} 个 skills");
}
uninstall_hook(args.global, platform)?;
Ok(())
}
fn uninstall_hook(global: bool, platform: AgentPlatform) -> miette::Result<()> {
let (hook_dir, settings_path) = if global {
let home = dirs::home_dir().ok_or_else(|| miette::miette!("无法确定 HOME 目录"))?;
(
home.join(platform.hooks_dir_name()),
home.join(platform.settings_file_path()),
)
} else {
let repo = git_repo_root()?;
(
repo.join(platform.hooks_dir_name()),
repo.join(platform.settings_file_path()),
)
};
let hook_script = hook_dir.join("auto-report-bug.sh");
if hook_script.exists() {
std::fs::remove_file(&hook_script)
.map_err(|e| miette::miette!("无法删除 hook 脚本 {}: {e}", hook_script.display()))?;
if hook_dir.exists()
&& std::fs::read_dir(&hook_dir).map_or(true, |mut d| d.next().is_none())
{
std::fs::remove_dir(&hook_dir).ok();
}
}
if !settings_path.exists() {
return Ok(());
}
let content = std::fs::read_to_string(&settings_path)
.map_err(|e| miette::miette!("无法读取配置: {e}"))?;
let mut json: serde_json::Value =
serde_json::from_str(&content).map_err(|e| miette::miette!("无法解析: {e}"))?;
if let Some(obj) = json.as_object_mut()
&& let Some(hooks) = obj.get_mut("hooks")
&& let Some(stop) = hooks.get_mut("Stop")
&& let Some(arr) = stop.as_array_mut()
{
arr.retain(|v| v.get("matcher").and_then(|m| m.as_str()) != Some("gitflow"));
}
let formatted =
serde_json::to_string_pretty(&json).map_err(|e| miette::miette!("JSON: {e}"))?;
std::fs::write(&settings_path, formatted).map_err(|e| miette::miette!("写入: {e}"))?;
println!("✅ Hook 已卸载");
Ok(())
}
fn try_enable_co_contribution(platform: AgentPlatform) -> miette::Result<()> {
if !std::io::stderr().is_terminal() {
println!("ℹ️ 非交互模式,已跳过共建计划");
return Ok(());
}
if let Some(home) = dirs::home_dir() {
let (_hook_dir, settings_path, _cmd) = resolve_global_hook_paths(&home, platform);
if read_co_contribution_flag(&settings_path) {
return Ok(());
}
}
println!();
println!("🤝 共建计划:加入后,CLI 错误将自动上报为 GitHub Issue,帮助改进 gitflow-cli。");
println!(" 用户级设置,加入一次即所有项目生效。");
println!();
if !confirm("是否加入共建计划?", true)? {
println!("已跳过共建计划。你可以稍后运行 `skills install --force` 重新加入。");
return Ok(());
}
let auth_provider = gitflow_cli_github::GitHubAuthProvider::new();
if auth_provider.is_authenticated() {
merge_co_contribution(platform)?;
println!("✅ 共建计划已激活");
} else {
println!("⚠️ 未检测到 GitHub 登录。");
if confirm("是否现在执行 `gh auth login`?", true)? {
let status = std::process::Command::new("gh")
.args(["auth", "login"])
.stdin(std::process::Stdio::inherit())
.stdout(std::process::Stdio::inherit())
.stderr(std::process::Stdio::inherit())
.status();
match status {
Ok(s) if s.success() => {
merge_co_contribution(platform)?;
println!("✅ 共建计划已激活");
}
_ => {
println!(
"登录失败。请手动运行 `gh auth login`,然后重新 `skills install --force`。"
);
}
}
} else {
println!(
"请手动运行 `gh auth login`,然后重新 `skills install --force` 激活共建计划。"
);
}
}
Ok(())
}
fn merge_co_contribution_json(mut json: serde_json::Value, joined_at: &str) -> serde_json::Value {
if let serde_json::Value::Object(ref mut obj) = json {
let gitflow = obj.entry("gitflow").or_insert(serde_json::json!({}));
if let serde_json::Value::Object(gf) = gitflow {
gf.insert("co_contribution".into(), serde_json::json!(true));
gf.insert("joined_at".into(), serde_json::json!(joined_at));
}
} else {
json = serde_json::json!({
"gitflow": {
"co_contribution": true,
"joined_at": joined_at
}
});
}
json
}
fn merge_co_contribution(platform: AgentPlatform) -> miette::Result<()> {
let home = dirs::home_dir().ok_or_else(|| miette::miette!("无法确定 HOME 目录"))?;
let (_hook_dir, settings_path, _cmd) = resolve_global_hook_paths(&home, platform);
let existing = if settings_path.exists() {
let content = std::fs::read_to_string(&settings_path)
.map_err(|e| miette::miette!("无法读取配置 {}: {e}", settings_path.display()))?;
serde_json::from_str::<serde_json::Value>(&content)
.map_err(|e| miette::miette!("无法解析配置 {}: {e}", settings_path.display()))?
} else {
serde_json::json!({})
};
let joined_at = iso8601_utc_now_co_contribution();
let new_settings = merge_co_contribution_json(existing, &joined_at);
let formatted = serde_json::to_string_pretty(&new_settings)
.map_err(|e| miette::miette!("JSON 序列化失败: {e}"))?;
if let Some(parent) = settings_path.parent() {
std::fs::create_dir_all(parent)
.map_err(|e| miette::miette!("无法创建目录 {}: {e}", parent.display()))?;
}
std::fs::write(&settings_path, formatted)
.map_err(|e| miette::miette!("写入配置失败 {}: {e}", settings_path.display()))?;
Ok(())
}
#[allow(
dead_code,
reason = "called by `merge_co_contribution`; direct calls from tests for isolation"
)]
#[allow(
clippy::cast_possible_wrap,
clippy::cast_lossless,
clippy::cast_sign_loss,
reason = "Howard Hinnant's algorithm operates on mixed-sign integer ranges within known bounds"
)]
fn iso8601_utc_now_co_contribution() -> String {
let secs = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_secs());
let day_secs = secs % 86_400;
let hours = day_secs / 3_600;
let minutes = (day_secs % 3_600) / 60;
let seconds = day_secs % 60;
let days = (secs / 86_400) as i64;
let z = days + 719_468;
let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
let doe = (z - era * 146_097) as u64;
let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365;
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
let mp = (5 * doy + 2) / 153;
let d = doy - (153 * mp + 2) / 5 + 1;
let m = if mp < 10 { mp + 3 } else { mp - 9 };
let y = yoe as i64 + era * 400;
let y = if m <= 2 { y + 1 } else { y };
format!("{y:04}-{m:02}-{d:02}T{hours:02}:{minutes:02}:{seconds:02}Z")
}
fn copy_dir_all(src: &PathBuf, dst: &PathBuf) -> std::io::Result<()> {
std::fs::create_dir_all(dst)?;
for entry in std::fs::read_dir(src)? {
let entry = entry?;
let ty = entry.file_type()?;
let dest_path = dst.join(entry.file_name());
if ty.is_dir() {
copy_dir_all(&entry.path(), &dest_path)?;
} else {
std::fs::copy(entry.path(), &dest_path)?;
}
}
Ok(())
}
fn confirm(prompt: &str, default: bool) -> miette::Result<bool> {
let stdin = std::io::stdin();
let mut reader = stdin.lock();
confirm_with_reader(prompt, default, &mut reader)
}
#[allow(
dead_code,
reason = "called by `confirm`; direct calls from tests for isolation"
)]
fn confirm_with_reader(
prompt: &str,
default: bool,
reader: &mut impl std::io::BufRead,
) -> miette::Result<bool> {
use std::io::Write;
let hint = if default { "[Y/n]" } else { "[y/N]" };
print!("{prompt} {hint} ");
let _ = std::io::stdout().flush();
for _ in 0..3 {
let mut line = String::new();
let bytes_read = reader
.read_line(&mut line)
.map_err(|e| miette::miette!("读取输入失败: {e}"))?;
if bytes_read == 0 {
return Ok(default);
}
match line.trim().to_lowercase().as_str() {
"" => return Ok(default),
"y" | "yes" => return Ok(true),
"n" | "no" => return Ok(false),
_ => {
print!("请输入 y 或 n: ");
let _ = std::io::stdout().flush();
}
}
}
Ok(default)
}
#[cfg(test)]
#[allow(
clippy::expect_used,
clippy::unwrap_used,
clippy::panic,
reason = "允许在测试中使用 expect/unwrap/panic"
)]
mod tests {
use super::*;
#[test]
fn test_agent_platform_claude_dir() {
assert_eq!(AgentPlatform::Claude.skills_dir_name(), ".claude/skills");
}
#[test]
fn test_agent_platform_codex_dir() {
assert_eq!(AgentPlatform::Codex.skills_dir_name(), ".codex/skills");
}
#[test]
fn test_agent_platform_opencode_dir() {
assert_eq!(
AgentPlatform::OpenCode.skills_dir_name(),
".opencode/skills"
);
}
#[test]
fn test_agent_detect_always_returns_claude() {
assert_eq!(AgentPlatform::detect(), AgentPlatform::Claude);
}
#[test]
fn test_agent_platform_claude_hooks_dir() {
assert_eq!(AgentPlatform::Claude.hooks_dir_name(), ".claude/hooks");
}
#[test]
fn test_agent_platform_codex_hooks_dir() {
assert_eq!(AgentPlatform::Codex.hooks_dir_name(), ".codex/hooks");
}
#[test]
fn test_agent_platform_opencode_hooks_dir() {
assert_eq!(AgentPlatform::OpenCode.hooks_dir_name(), ".opencode/hooks");
}
#[test]
fn test_agent_platform_gemini_hooks_dir() {
assert_eq!(AgentPlatform::Gemini.hooks_dir_name(), ".gemini/hooks");
}
#[test]
fn test_agent_platform_copilot_hooks_dir() {
assert_eq!(AgentPlatform::Copilot.hooks_dir_name(), ".copilot/hooks");
}
#[test]
fn test_agent_platform_claude_settings_path() {
assert_eq!(
AgentPlatform::Claude.settings_file_path(),
".claude/settings.json"
);
}
#[test]
fn test_agent_platform_codex_settings_path() {
assert_eq!(
AgentPlatform::Codex.settings_file_path(),
".codex/settings.json"
);
}
#[test]
fn test_agent_platform_opencode_settings_path() {
assert_eq!(
AgentPlatform::OpenCode.settings_file_path(),
".opencode/settings.json"
);
}
#[test]
fn test_agent_platform_gemini_settings_path() {
assert_eq!(
AgentPlatform::Gemini.settings_file_path(),
".gemini/settings.json"
);
}
#[test]
fn test_agent_platform_copilot_settings_path() {
assert_eq!(
AgentPlatform::Copilot.settings_file_path(),
".copilot/settings.json"
);
}
#[test]
fn test_resolve_global_target_claude() {
let dir = resolve_target_dir(true, Some(AgentPlatform::Claude), None).expect("resolve");
assert!(dir.ends_with(".claude/skills"));
}
#[test]
fn test_resolve_global_target_codex() {
let dir = resolve_target_dir(true, Some(AgentPlatform::Codex), None).expect("resolve");
assert!(dir.ends_with(".codex/skills"));
}
#[test]
fn test_resolve_global_target_gemini() {
let dir = resolve_target_dir(true, Some(AgentPlatform::Gemini), None).expect("resolve");
assert!(dir.ends_with(".gemini/skills"));
}
#[test]
fn test_resolve_project_target_respects_agent() {
let repo = PathBuf::from("/tmp/test-repo-skills");
let dir = resolve_project_target(&repo, AgentPlatform::Codex);
assert!(
dir.ends_with(".codex/skills"),
"project-level install must respect --agent, got {}",
dir.display()
);
let dir_gemini = resolve_project_target(&repo, AgentPlatform::Gemini);
assert!(dir_gemini.ends_with(".gemini/skills"));
}
#[test]
fn test_agent_supports_hooks_matrix() {
assert!(AgentPlatform::Claude.supports_hooks());
assert!(AgentPlatform::Codex.supports_hooks());
assert!(!AgentPlatform::OpenCode.supports_hooks());
assert!(!AgentPlatform::Gemini.supports_hooks());
assert!(!AgentPlatform::Copilot.supports_hooks());
}
#[test]
fn test_resolve_custom_path_overrides_all() {
let dir = resolve_target_dir(false, Some(AgentPlatform::Claude), Some("/tmp/my-skills"))
.expect("resolve");
assert_eq!(dir, PathBuf::from("/tmp/my-skills"));
}
#[test]
fn test_skills_source_dir_is_valid_path() {
let dir = skills_source_dir();
assert!(dir.ends_with("skills"));
}
#[test]
fn test_merge_stop_hook_creates_nested_format() {
let input = serde_json::json!({});
let result = merge_stop_hook(input, "bash hooks/auto-report-bug.sh");
let hooks = result
.pointer("/hooks/Stop/0/hooks")
.and_then(serde_json::Value::as_array)
.expect("should create nested hooks array");
assert_eq!(hooks.len(), 1);
assert_eq!(
hooks[0].get("type").and_then(serde_json::Value::as_str),
Some("command")
);
assert_eq!(
hooks[0].get("command").and_then(serde_json::Value::as_str),
Some("bash hooks/auto-report-bug.sh")
);
assert_eq!(
result
.pointer("/hooks/Stop/0/matcher")
.and_then(serde_json::Value::as_str),
Some("gitflow")
);
}
#[test]
fn test_merge_stop_hook_replaces_existing_gitflow() {
let input = serde_json::json!({
"hooks": {
"Stop": [
{
"matcher": "gitflow",
"command": "old-command.sh"
}
]
}
});
let result = merge_stop_hook(input, "bash hooks/auto-report-bug.sh");
let stop = result
.pointer("/hooks/Stop")
.and_then(serde_json::Value::as_array)
.expect("Stop array should exist");
assert_eq!(stop.len(), 1, "should replace, not duplicate");
assert!(
stop[0].get("hooks").is_some(),
"should use nested hooks format"
);
assert!(
stop[0].get("command").is_none(),
"flat command field should be gone"
);
}
#[test]
fn test_merge_stop_hook_preserves_other_hooks() {
let input = serde_json::json!({
"hooks": {
"Stop": [
{
"matcher": "other-agent",
"hooks": [
{
"type": "command",
"command": "other-command.sh"
}
]
}
]
}
});
let result = merge_stop_hook(input, "bash hooks/auto-report-bug.sh");
let stop = result
.pointer("/hooks/Stop")
.and_then(serde_json::Value::as_array)
.expect("Stop array should exist");
assert_eq!(stop.len(), 2, "should keep other matcher and add gitflow");
}
#[cfg(unix)]
#[test]
fn test_uninstall_hook_removes_gitflow() {
let tmp = tempfile::tempdir().expect("create temp dir");
let settings_path = tmp.path().join(".claude/settings.json");
std::fs::create_dir_all(tmp.path().join(".claude")).expect("create .claude dir");
let content = serde_json::json!({
"hooks": {
"Stop": [
{
"matcher": "gitflow",
"hooks": [
{
"type": "command",
"command": "bash hooks/auto-report-bug.sh"
}
]
}
]
}
});
std::fs::write(
&settings_path,
serde_json::to_string_pretty(&content).expect("serialize"),
)
.expect("write settings");
temp_env::with_var("HOME", Some(tmp.path()), || {
super::uninstall_hook(true, AgentPlatform::Claude).expect("uninstall should succeed");
});
let after = std::fs::read_to_string(&settings_path).expect("read after");
let parsed: serde_json::Value = serde_json::from_str(&after).expect("parse after");
let stop = parsed
.pointer("/hooks/Stop")
.and_then(serde_json::Value::as_array)
.expect("Stop should exist");
assert!(
stop.iter()
.all(|v| v.get("matcher").and_then(serde_json::Value::as_str) != Some("gitflow")),
"gitflow hook should be removed"
);
}
#[cfg(unix)]
#[test]
fn test_uninstall_hook_preserves_others() {
let tmp = tempfile::tempdir().expect("create temp dir");
let settings_path = tmp.path().join(".claude/settings.json");
std::fs::create_dir_all(tmp.path().join(".claude")).expect("create .claude dir");
let content = serde_json::json!({
"hooks": {
"Stop": [
{
"matcher": "gitflow",
"hooks": [
{
"type": "command",
"command": "bash hooks/auto-report-bug.sh"
}
]
},
{
"matcher": "other-agent",
"hooks": [
{
"type": "command",
"command": "other.sh"
}
]
}
]
}
});
std::fs::write(
&settings_path,
serde_json::to_string_pretty(&content).expect("serialize"),
)
.expect("write settings");
temp_env::with_var("HOME", Some(tmp.path()), || {
super::uninstall_hook(true, AgentPlatform::Claude).expect("uninstall should succeed");
});
let after = std::fs::read_to_string(&settings_path).expect("read after");
let parsed: serde_json::Value = serde_json::from_str(&after).expect("parse after");
let stop = parsed
.pointer("/hooks/Stop")
.and_then(serde_json::Value::as_array)
.expect("Stop should exist");
assert_eq!(stop.len(), 1, "other-agent hook should remain");
assert_eq!(
stop[0].get("matcher").and_then(serde_json::Value::as_str),
Some("other-agent")
);
}
#[cfg(unix)]
#[test]
fn test_uninstall_hook_deletes_script_file_and_empty_dir() {
let tmp = tempfile::tempdir().expect("create temp dir");
let hooks_dir = tmp.path().join(".claude/hooks");
std::fs::create_dir_all(&hooks_dir).expect("create hooks dir");
let hook_script = hooks_dir.join("auto-report-bug.sh");
std::fs::write(&hook_script, b"#!/bin/bash\necho test\n").expect("write hook script");
let settings_path = tmp.path().join(".claude/settings.json");
let content = serde_json::json!({
"hooks": {
"Stop": [
{
"matcher": "gitflow",
"hooks": [
{
"type": "command",
"command": "bash .claude/hooks/auto-report-bug.sh"
}
]
}
]
}
});
std::fs::write(
&settings_path,
serde_json::to_string_pretty(&content).expect("serialize"),
)
.expect("write settings");
temp_env::with_var("HOME", Some(tmp.path()), || {
super::uninstall_hook(true, AgentPlatform::Claude).expect("uninstall should succeed");
});
assert!(
!hook_script.exists(),
"hook script should be deleted by uninstall"
);
assert!(
!hooks_dir.exists(),
"empty hooks directory should be removed"
);
}
#[test]
fn test_resolve_project_hook_paths_uses_hooks_dir() {
let repo = PathBuf::from("/tmp/test-repo");
let (hook_dir, settings_path, cmd) =
resolve_project_hook_paths(&repo, AgentPlatform::Claude);
assert_eq!(
hook_dir,
repo.join(".claude/hooks"),
"hook should be in .claude/hooks/"
);
assert_eq!(settings_path, repo.join(".claude/settings.json"));
assert!(
cmd.contains(".claude/hooks/auto-report-bug.sh"),
"command should reference .claude/hooks/ path"
);
}
#[test]
fn test_resolve_global_hook_paths_uses_claude_hooks_dir() {
let home = PathBuf::from("/home/user");
let (hook_dir, settings_path, cmd) =
resolve_global_hook_paths(&home, AgentPlatform::Claude);
assert_eq!(hook_dir, home.join(".claude/hooks"));
assert_eq!(settings_path, home.join(".claude/settings.json"));
assert!(cmd.contains("~/.claude/hooks/auto-report-bug.sh"));
}
#[test]
fn test_should_parse_report_bug_false() {
use clap::Parser;
#[derive(Debug, Parser)]
struct TestCli {
#[command(subcommand)]
cmd: TestCmd,
}
#[derive(Debug, Subcommand)]
enum TestCmd {
Install(InstallArgs),
}
let cli = TestCli::parse_from(["test", "install", "--report-bug=false"]);
let TestCmd::Install(args) = cli.cmd;
assert!(
!args.report_bug,
"--report-bug=false must set report_bug to false"
);
}
#[test]
fn test_should_default_report_bug_to_true() {
use clap::Parser;
#[derive(Debug, Parser)]
struct TestCli {
#[command(subcommand)]
cmd: TestCmd,
}
#[derive(Debug, Subcommand)]
enum TestCmd {
Install(InstallArgs),
}
let cli = TestCli::parse_from(["test", "install"]);
let TestCmd::Install(args) = cli.cmd;
assert!(args.report_bug, "report_bug must default to true");
}
#[test]
fn test_should_count_overwritten_in_bundled_path() {
let tmp = tempfile::tempdir().expect("create temp dir");
let dest_fresh = tmp.path().join("fresh-skill");
let args = InstallArgs {
agent: Some(AgentPlatform::Claude),
global: false,
force: true,
report_bug: false,
custom_path: None,
};
let files: &[(&str, &[u8])] = &[("test.md", b"# Test Skill")];
let mut installed = 0u32;
let mut skipped = 0u32;
let mut overwritten = 0u32;
install_single_skill_bundled(
&dest_fresh,
files,
&args,
&mut installed,
&mut skipped,
&mut overwritten,
)
.expect("install should succeed");
assert_eq!(
overwritten, 0,
"fresh install with force=true should NOT count as overwritten"
);
assert_eq!(installed, 1, "fresh install should count as installed");
assert_eq!(skipped, 0, "fresh install should not count as skipped");
let mut installed = 0u32;
let mut skipped = 0u32;
let mut overwritten = 0u32;
let dest_existing = tmp.path().join("existing-skill");
std::fs::create_dir_all(&dest_existing).expect("create dest dir");
std::fs::write(dest_existing.join("old.txt"), b"old data").expect("write old file");
install_single_skill_bundled(
&dest_existing,
files,
&args,
&mut installed,
&mut skipped,
&mut overwritten,
)
.expect("install should succeed");
assert_eq!(
overwritten, 1,
"overwrite of existing dir with force=true should increment overwritten"
);
assert_eq!(installed, 0, "overwrite should not count as fresh install");
assert_eq!(
skipped, 0,
"overwrite with force should not count as skipped"
);
}
#[test]
fn test_should_return_default_on_empty_input() {
let input = b"\n";
let result = confirm_with_reader("Continue?", true, &mut &input[..]).expect("confirm");
assert!(result, "empty input should return default=true");
let result = confirm_with_reader("Continue?", false, &mut &input[..]).expect("confirm");
assert!(!result, "empty input should return default=false");
}
#[test]
fn test_should_accept_yes_variants() {
for answer in &[b"y\n" as &[u8], b"Y\n", b"yes\n", b"YES\n"] {
let result = confirm_with_reader("Continue?", false, &mut &**answer).expect("confirm");
assert!(result, "input {answer:?} should be accepted as yes");
}
}
#[test]
fn test_should_accept_no_variants() {
for answer in &[b"n\n" as &[u8], b"N\n", b"no\n", b"NO\n"] {
let result = confirm_with_reader("Continue?", true, &mut &**answer).expect("confirm");
assert!(!result, "input {answer:?} should be accepted as no");
}
}
#[test]
fn test_should_return_default_on_eof() {
let input: &[u8] = b"";
let result = confirm_with_reader("Continue?", true, &mut &input[..]).expect("confirm");
assert!(result, "EOF should return default=true");
}
#[test]
fn test_should_merge_co_contribution_into_empty_settings() {
let input = serde_json::json!({});
let result = merge_co_contribution_json(input, "2026-07-09T08:30:00Z");
assert_eq!(
result
.pointer("/gitflow/co_contribution")
.and_then(serde_json::Value::as_bool),
Some(true)
);
assert_eq!(
result
.pointer("/gitflow/joined_at")
.and_then(serde_json::Value::as_str),
Some("2026-07-09T08:30:00Z")
);
}
#[test]
fn test_should_preserve_existing_hooks_when_merging_co_contribution() {
let input = serde_json::json!({
"hooks": {
"Stop": [
{
"matcher": "gitflow",
"hooks": [{"type": "command", "command": "bash hook.sh"}]
}
]
}
});
let result = merge_co_contribution_json(input, "2026-07-09T08:30:00Z");
let stop = result
.pointer("/hooks/Stop")
.and_then(serde_json::Value::as_array);
assert!(stop.is_some(), "existing hooks must be preserved");
assert_eq!(stop.expect("stop array").len(), 1);
assert_eq!(
result
.pointer("/gitflow/co_contribution")
.and_then(serde_json::Value::as_bool),
Some(true)
);
}
#[test]
fn test_should_update_existing_gitflow_section() {
let input = serde_json::json!({
"gitflow": {
"co_contribution": false,
"joined_at": "2020-01-01T00:00:00Z"
}
});
let result = merge_co_contribution_json(input, "2026-07-09T08:30:00Z");
assert_eq!(
result
.pointer("/gitflow/co_contribution")
.and_then(serde_json::Value::as_bool),
Some(true),
"co_contribution must be updated to true"
);
assert_eq!(
result
.pointer("/gitflow/joined_at")
.and_then(serde_json::Value::as_str),
Some("2026-07-09T08:30:00Z"),
"joined_at must be updated"
);
}
#[cfg(unix)]
#[test]
fn test_should_write_co_contribution_to_global_path() {
let temp = tempfile::tempdir().expect("tempdir");
let home = temp.path();
temp_env::with_var("HOME", Some(home), || {
let result = merge_co_contribution(AgentPlatform::Claude);
assert!(
result.is_ok(),
"merge_co_contribution should succeed: {:?}",
result.err()
);
let global_settings = home.join(".claude/settings.json");
assert!(
global_settings.exists(),
"global settings.json must be created"
);
let content = std::fs::read_to_string(&global_settings).expect("read");
let json: serde_json::Value = serde_json::from_str(&content).expect("parse");
assert_eq!(
json.pointer("/gitflow/co_contribution")
.and_then(serde_json::Value::as_bool),
Some(true),
"co_contribution must be true in global settings"
);
assert!(
json.pointer("/gitflow/joined_at")
.and_then(serde_json::Value::as_str)
.is_some(),
"joined_at must be set in global settings"
);
});
}
#[cfg(unix)]
#[test]
fn test_should_skip_prompt_when_co_contribution_already_enabled() {
let temp = tempfile::tempdir().expect("tempdir");
let home = temp.path();
let settings_path = home.join(".claude/settings.json");
std::fs::create_dir_all(home.join(".claude")).expect("create .claude dir");
std::fs::write(
&settings_path,
r#"{"gitflow": {"co_contribution": true, "joined_at": "2026-07-09T08:30:00Z"}}"#,
)
.expect("write settings");
temp_env::with_var("HOME", Some(home), || {
let result = try_enable_co_contribution(AgentPlatform::Claude);
assert!(
result.is_ok(),
"try_enable_co_contribution should succeed when already joined: {:?}",
result.err()
);
let content = std::fs::read_to_string(&settings_path).expect("read");
let json: serde_json::Value = serde_json::from_str(&content).expect("parse");
assert_eq!(
json.pointer("/gitflow/joined_at")
.and_then(serde_json::Value::as_str),
Some("2026-07-09T08:30:00Z"),
"joined_at must not be modified when already joined"
);
});
}
}