code_repo_wiki/

commands.rs

use anyhow::{Context, Result};
use std::collections::HashMap;
use std::path::{Path, PathBuf};

use crate::config::schema::WikiConfig;
use crate::incremental::state::GenerationState;
use crate::output::lint::{lint, LintIssue};

/// status 报告（结构化，main 只做格式化）
pub struct StatusReport {
    pub ready: bool,            // 产物根存在且非空
    pub wiki_pages: usize,      // wiki/{lang}/*.md 数量（所有语言合计）
    pub cards: usize,           // cards/{lang}/*.md 数量
    pub issues: Vec<LintIssue>, // lint 产物健康检查结果
    pub config_path: String,
}

/// 汇总产物状态：页面/卡片数量 + lint 健康检查（供 `code-repo-wiki status` 使用）
///
/// 目录不存在时数量计 0、lint 无问题，不算缺陷（未生成也是合法状态）。
pub fn status_report(config: &WikiConfig, root: &crate::project::ProjectRoot) -> StatusReport {
    let output_dir = config.output_dir();
    // ready = wiki 目录存在且含 .md 文件（有产物才算生成过）
    let wiki_pages = collect_md_files(&output_dir.join("wiki")).len();
    let cards = collect_md_files(&output_dir.join("cards")).len();
    // 源码根必须相对 root 解析（见 source_roots）：status 跨 cwd 运行时
    // （--root 指向其他仓库）lint 才能扫到目标仓库
    let issues = lint(
        output_dir,
        &source_roots(root),
    );
    StatusReport {
        ready: wiki_pages > 0,
        wiki_pages,
        cards,
        issues,
        config_path: config.output_dir().to_string_lossy().into_owned(),
    }
}

/// 源码根（v30+：扫描范围已硬编码为全量遍历+内置过滤，源码根恒为仓库根）
///
/// lint 过时检查需要对比源文件 mtime，空根会导致检查静默跳过；
/// main.rs 的 lint 命令与 status 共用此派生，避免两处内联逻辑漂移。
pub fn source_roots(root: &crate::project::ProjectRoot) -> Vec<PathBuf> {
    vec![root.path().to_path_buf()]
}

/// 将产物目录（wiki/{lang}/、cards/{lang}/）的工作区内容同步到指纹库
///
/// 官方语义：Git 目录中直接编辑 .md 后，手动触发"同步"以 Git 内容为准
/// 合入 Wiki（团队 pull 共享知识的场景）。对每个 .md 产物：
/// - 指纹不存在 → 记录新指纹（视为新文件）
/// - 指纹不匹配 → 工作区内容为准，更新指纹
/// - 受保护页面（protected_docs 含该路径）→ 跳过，保留人工版
///
/// 本质上 = 重新加载工作区 .md 内容到指纹库，不触发任何 LLM 生成。
pub fn sync_from_git(output_dir: &Path) -> Result<()> {
    let state_dir = output_dir.join(".state");
    let state_path = state_dir.join("generation_state.json");
    // 状态不存在（首次 sync）→ 从空状态开始：所有产物视为新文件，全部记录指纹。
    // 状态存在但损坏 → 显式报错（不静默重置：空状态会丢失 protected_docs，
    // 使人工修改保护在后续 update 中失效）。
    let mut state = if !state_path.exists() {
        GenerationState {
            last_commit_hash: None,
            file_fingerprints: HashMap::new(),
            doc_fingerprints: HashMap::new(),
            doc_modules: HashMap::new(),
            protected_docs: Vec::new(),
            generated_at: chrono::Utc::now().to_rfc3339(),
            tool_version: None,
            failed_modules: vec![],
        }
    } else {
        GenerationState::load(&state_dir)
            .with_context(|| format!("状态文件损坏，拒绝静默重置（保护信息会丢失）: {}", state_path.display()))?
    };

    let mut updated = 0usize;
    let mut skipped = 0usize;
    for root in [output_dir.join("wiki"), output_dir.join("cards")] {
        for path in collect_md_files(&root) {
            let path_str = path.to_string_lossy().to_string();
            if state.protected_docs.iter().any(|p| p == &path_str) {
                tracing::warn!("跳过受保护页面（保留人工版）: {}", path_str);
                skipped += 1;
                continue;
            }
            let fp = GenerationState::compute_file_fingerprint(&path)?;
            if state.doc_fingerprints.get(&path_str) != Some(&fp) {
                state.doc_fingerprints.insert(path_str, fp);
                updated += 1;
                tracing::info!("同步指纹（工作区内容为准）: {}", path.display());
            }
        }
    }

    state.save(&state_dir)?;
    tracing::info!("同步完成: 指纹更新 {} 个, 跳过受保护 {} 个", updated, skipped);
    Ok(())
}

/// 追加一条知识沉淀记录到 `{output_dir}/wiki/{lang}/_log.md`（Karpathy log.md 模式）
///
/// 每条记录以 `## YYYY-MM-DD` 节组织，节内按追加顺序编号（当天第 N 条）。
/// _log.md 是人工可读、grep 可查、git 可追踪的追加式会话知识日志——
/// 与 wiki 页（LLM 生成、受保护）分开：人工记录永不被自动生成覆盖。
/// 文件不存在时自动创建；目录不存在时自动创建（与 render_all 的写盘约定一致）。
pub fn append_note(output_dir: &Path, language: &str, text: &str) -> Result<()> {
    let text = text.trim();
    if text.is_empty() {
        anyhow::bail!("note 内容不能为空");
    }
    let log_dir = output_dir.join("wiki").join(language);
    std::fs::create_dir_all(&log_dir)?;
    let log_path = log_dir.join("_log.md");

    // 读取现有内容以确定今天的节内已有几条（追加式，不重写历史）
    let existing = std::fs::read_to_string(&log_path).unwrap_or_default();
    let date = chrono::Local::now().format("%Y-%m-%d").to_string();
    let today_header = format!("## {date}");
    // 今天节内已有条数 = 文件中今天节之后出现的 "- N." 数量
    let today_seq = existing
        .split(&today_header)
        .nth(1)
        .map(|after| {
            after
                .lines()
                .filter(|l| l.trim().starts_with("- "))
                .count()
        })
        .unwrap_or(0);

    // 追加：无今天节则新建节，否则续写
    let entry = format!("- {}. {text}\n", today_seq + 1);
    let mut append = String::new();
    if !existing.contains(&today_header) {
        // 已有内容不以换行结尾时先补一行（避免与上一个节粘连）
        if !existing.is_empty() && !existing.ends_with('\n') {
            append.push('\n');
        }
        append.push_str(&today_header);
        append.push('\n');
    }
    append.push_str(&entry);

    let mut file = std::fs::OpenOptions::new()
        .create(true)
        .append(true)
        .open(&log_path)?;
    use std::io::Write;
    file.write_all(append.as_bytes())?;
    tracing::info!("知识记录已追加: {}", log_path.display());
    Ok(())
}

/// 递归收集目录下所有 .md 文件（目录不存在时返回空列表）
fn collect_md_files(dir: &Path) -> Vec<PathBuf> {
    let mut out = Vec::new();
    let Ok(entries) = std::fs::read_dir(dir) else {
        return out;
    };
    for entry in entries.flatten() {
        let p = entry.path();
        if p.is_dir() {
            out.extend(collect_md_files(&p));
        } else if p.extension().is_some_and(|e| e == "md") {
            out.push(p);
        }
    }
    out
}

/// install 的可选集成（v33 多 Agent 支持）
///
/// 默认集成集 = OpenCode 插件 + OpenCode MCP（用户级全局）+ AGENTS.md
/// + git hooks；以下 flag 扩展集成面。
#[derive(Debug, Clone, Copy, Default)]
pub struct InstallOptions {
    /// 额外注册 Claude Code MCP（--claude，用户级 `~/.claude.json` 顶层
    /// mcpServers，User scope——command 绑定本机 exe 路径=用户级内容，与
    /// opencode/codex 全局注册对称；v39 起不再写项目根 .mcp.json）；
    /// 同时同步注入 CLAUDE.md（Claude Code 不读 AGENTS.md，注册 MCP 时
    /// 必然需要文档指引——原 --also-claude 开关合并于此）
    pub claude: bool,
    /// 额外写 Codex CLI 用户级配置 `~/.codex/config.toml`（--codex）
    pub codex: bool,
}

/// code-repo-wiki 安装（v33 合并版）：OpenCode 插件 + 多 Agent MCP + AGENTS.md + git hooks
///
/// root 为项目根（U02：--root 注入，替代进程 cwd——插件/hook/config 全部
/// 相对项目根解析，跨 cwd 运行不再错位）。
///
/// 集成步骤（全部幂等，重复执行安全；非 code-repo-wiki 内容一律保留）：
/// 1. OpenCode 插件：用户级配置根 `~/.config/opencode/plugins/code-repo-wiki.ts`
///    （v39：插件是用户级内容——装进 Agent 配置根目录，官方自动加载目录，
///    一次 install 全仓库 opencode 会话可用；不再写入项目 `.opencode/plugins/`，
///    旧版项目级产物自动迁移清理）；模板注入 current_exe 绝对路径
///    （t02 摆脱 PATH 依赖）；内容与模板不同即升级
/// 2. OpenCode MCP：用户级全局 `opencode.json` 的 `mcp.code-repo-wiki` 条目
///    （v33 拍板：一次注册所有仓库可用，server 以工作区为 cwd）
/// 3. Claude MCP（--claude）：用户级 `~/.claude.json` 顶层 mcpServers 条目
///    （Claude Code 官方 User scope，command 绑定本机 exe=用户级内容；
///    v39 起不再写项目根 .mcp.json——机器相关配置不入团队共享文件）
/// 4. Codex MCP（--codex）：用户级 `~/.codex/config.toml` 的
///    `[mcp_servers.code-repo-wiki]` 表（Codex 官方用户级配置）
/// 5. AGENTS.md：wiki 引用块（标记对幂等替换；默认执行）
/// 6. CLAUDE.md（随 --claude，v36 起）：Claude Code 不读 AGENTS.md，
///    注册 Claude MCP 时同步注入引用块
/// 7. git hooks：post-commit/post-merge（含 code-repo-wiki 标记则升级覆盖；
///    用户自定义 hook 保留并提示）
///
/// 用户级默认配置的确保由调用方（main.rs）先行执行（v25 语义）。
pub fn install(root: &crate::project::ProjectRoot, opts: &InstallOptions) -> Result<()> {
    let project_root = root.path();

    // MCP 与插件共用当前可执行文件绝对路径（t02：不依赖 PATH）
    let exe_path = std::env::current_exe()
        .context("无法定位当前可执行文件路径（集成无法绑定绝对路径）")?;
    let exe_str = exe_path.to_string_lossy().into_owned();
    let mcp_args = ["mcp".to_string()];

    // 1. OpenCode 插件（用户级配置根——v39：Agent 配置根目录安装）
    let mut oc = crate::config::opencode::OpenCodeConfig::new(root)
        .context("读取 OpenCode 配置失败")?;
    oc.install_plugin()?;
    if oc.install_plugin_file()? {
        println!("✓ OpenCode 插件已安装（用户级: ~/.config/opencode/plugins/）");
    } else {
        println!("✓ OpenCode 插件已是最新");
    }

    // 2. OpenCode MCP（用户级全局——v33 拍板）
    let opencode_mcp = crate::config::mcp::OpencodeMcp {
        config_path: crate::config::mcp::OpencodeMcp::global_path()?,
    };
    if opencode_mcp.install("code-repo-wiki", &[exe_str.clone(), mcp_args[0].clone()])? {
        println!("✓ OpenCode MCP 已注册（用户级全局）");
    } else {
        println!("✓ OpenCode MCP 已是最新");
    }

    // 3. Claude MCP（--claude → 用户级 ~/.claude.json User scope，v39）
    if opts.claude {
        let claude = crate::config::mcp::ClaudeMcp {
            path: crate::config::mcp::ClaudeMcp::user_global_path()?,
        };
        if claude.install("code-repo-wiki", &exe_str, &mcp_args)? {
            println!("✓ Claude Code MCP 已注册（用户级: ~/.claude.json）");
        } else {
            println!("✓ Claude Code MCP 已是最新（~/.claude.json）");
        }
    }

    // 4. Codex MCP（--codex → 用户级 ~/.codex/config.toml）
    if opts.codex {
        let codex = crate::config::mcp::CodexMcp {
            config_path: crate::config::mcp::CodexMcp::global_path()?,
        };
        if codex.install("code-repo-wiki", &exe_str, &mcp_args)? {
            println!("✓ Codex MCP 已注册（~/.codex/config.toml）");
        } else {
            println!("✓ Codex MCP 已是最新（~/.codex/config.toml）");
        }
    }

    // 5/6. AGENTS.md（默认）与 CLAUDE.md（v36 起随 --claude 同步——
    // Claude Code 不读 AGENTS.md，注册 MCP 时文档指引随之注入）
    install_wiki(root, opts.claude)?;

    // 7. git hooks（v41：新装独立脚本；既有用户 hook 尾部追加块共存）
    let hooks_present = install_hooks(project_root)?;

    println!("✓ code-repo-wiki 安装完成");
    println!();
    println!("日常使用（傻瓜式全自动，无需记忆命令）：");
    if hooks_present {
        println!("  1. git commit 后 wiki 自动增量更新（post-commit/post-merge hook 已配置）");
    } else {
        println!(
            "  1. git commit 后 wiki 自动增量更新——hook 未安装（未检测到 .git 目录），"
        );
        println!("     使用命令 2/3 手动/常驻更新");
    }
    println!("  2. 手动一条命令：code-repo-wiki update（首次自动全量生成，之后自动增量；");
    println!("     无变更秒回，失败模块自动补偿重试，尾部自动 lint 复核）");
    println!("  3. 常驻实时模式：code-repo-wiki watch（代码保存即自动更新，Ctrl-C 退出）");
    println!("  4. 健康检查：code-repo-wiki doctor / code-repo-wiki lint");
    Ok(())
}

/// git hook 追加块开始标记（v41 方案：与用户既有 hook 共存——尾部追加
/// 标记块，升级判定与卸载剥离判定共用「是否 code-repo-wiki 所有」判据；
/// 用户自定义 hook 不含此标记，不会被覆盖，只追加块）
pub const HOOK_MARKER: &str = "# code-repo-wiki: append-begin";

/// git hook 追加块结束标记（与 [`HOOK_MARKER`] 成对，剥离时按区间删除）
pub const HOOK_END_MARKER: &str = "# code-repo-wiki: append-end";

/// v37 改名前的 hook 标记（v33 旧模板——独立脚本式）。升级/卸载时一并
/// 识别——改名后旧 hook 里的 `repo-wiki update` 命令已不存在，残留只会
/// 静默失效。
pub const LEGACY_HOOK_MARKER: &str = "# repo-wiki managed";

/// hook 内容是否属于本工具（追加块标记、v37 旧标记、或 v33 前旧模板都
/// 算——旧 hook 是本工具旧版本的产物，升级剥离与卸载删除都应覆盖它）。
/// v33 前旧模板无 managed 标记，特征行是注释里的
/// `auto-update wiki on commit`（用户/第三方 hook 不会写这行）。
fn hook_is_ours(content: &str) -> bool {
    content.contains(HOOK_MARKER)
        || content.contains(LEGACY_HOOK_MARKER)
        || content.contains("auto-update wiki on commit")
}

/// 生成独立 hook 脚本内容（新装/整文件升级场景）
///
/// `#!/bin/sh` + LF：Windows 上由 Git for Windows 的 sh 执行（POSIX 语义，
/// 绝非 PowerShell）；`cd` 到仓库顶层保证 --root 无关；`command -v` 探测
/// 二进制存在性；update 失败不阻断 git 主流程（hook 是通知型），但
/// 失败必须可见：stderr 落 .code-repo-wiki/update-error.log 并在提交输出中
/// 提示一行（v36 D2：此前 2>/dev/null || true 把失败完全吞掉，用户
/// 永远不知道 wiki 已陈旧）。
fn hook_content() -> String {
    format!(
        "#!/bin/sh\n{0}: auto-update wiki on commit\ncd \"$(git rev-parse --show-toplevel)\"\ncommand -v code-repo-wiki >/dev/null 2>&1 || exit 0\nmkdir -p .code-repo-wiki\ncode-repo-wiki update 2>>.code-repo-wiki/update-error.log || echo \"code-repo-wiki: wiki 更新失败（详见 .code-repo-wiki/update-error.log）\" >&2\n",
        HOOK_MARKER
    )
}

/// 生成追加块内容（v41：无 shebang——追加在用户 hook 尾部；`cd` 到仓库
/// 顶层保证位置；每条命令带 `|| exit 0`/`|| echo` 满足 `set -e` 隔离——
/// 单条失败不传播为 git hook 失败，也不被静默吞掉）
fn hook_block() -> String {
    format!(
        "{0}\n# 自动更新 wiki（追加块，与仓库既有 hook 共存；用户 hook 若以 exit 结束，\n# 本块不会执行——post-commit 场景罕见，若需保证请移除既有 hook 后重装）\ncd \"$(git rev-parse --show-toplevel)\" 2>/dev/null || exit 0\ncommand -v code-repo-wiki >/dev/null 2>&1 || exit 0\nmkdir -p .code-repo-wiki 2>/dev/null || exit 0\ncode-repo-wiki update 2>>.code-repo-wiki/update-error.log || echo \"code-repo-wiki: wiki 更新失败（详见 .code-repo-wiki/update-error.log）\" >&2\n{1}\n",
        HOOK_MARKER, HOOK_END_MARKER
    )
}

/// 剥离追加块区间（begin 标记行到 end 标记行含两端），返回剩余内容。
/// 无区间时原样返回（幂等）。剥离后 trim——去掉区间剥除留下的多余空行。
fn strip_hook_block(content: &str) -> String {
    let lines: Vec<&str> = content.lines().collect();
    let begin = lines.iter().position(|l| l.trim() == HOOK_MARKER);
    let end = lines.iter().position(|l| l.trim() == HOOK_END_MARKER);
    match (begin, end) {
        (Some(b), Some(e)) if b <= e => {
            let mut kept: Vec<&str> = Vec::new();
            for (i, line) in lines.iter().enumerate() {
                if i < b || i > e {
                    kept.push(line);
                }
            }
            kept.join("\n").trim().to_string()
        }
        // 区间不完整（只有一端）→ 保守不动（不破坏用户 hook）
        _ => content.trim().to_string(),
    }
}

/// 在既有内容尾部追加块（块不存在时；已存在则整文件升级走
/// [`replace_hook_block`]）
fn append_hook_block(existing: &str, block: &str) -> String {
    format!("{}\n\n{}", existing.trim_end(), block)
}

/// 替换既有内容中的追加块区间（begin-end 整体替换为新块——升级场景，
/// 保留区间外的用户内容）
fn replace_hook_block(existing: &str, block: &str) -> String {
    let stripped = strip_hook_block(existing);
    format!("{}\n\n{}", stripped, block)
}

/// 原子写 hook 并设置执行位（unix；Windows 由 sh 解释执行无需执行位）
fn write_hook(path: &std::path::Path, content: &str) -> Result<()> {
    crate::fs::write_file_atomic(path, content)?;
    #[cfg(unix)]
    std::fs::set_permissions(path, std::os::unix::fs::PermissionsExt::from_mode(0o755))?;
    Ok(())
}

/// 检测 core.hooksPath 配置（v41）：Git 从该目录加载 hook——若指向
/// .git/hooks 之外，写入 .git/hooks 的 hook 不会生效，安装前必须提示。
/// 返回配置值（未配置返回 None）。
fn detect_core_hooks_path(project_root: &std::path::Path) -> Option<String> {
    let output = std::process::Command::new("git")
        .args(["config", "--get", "core.hooksPath"])
        .current_dir(project_root)
        .output()
        .ok()?;
    if !output.status.success() {
        return None;
    }
    let value = String::from_utf8_lossy(&output.stdout).trim().to_string();
    if value.is_empty() {
        None
    } else {
        Some(value)
    }
}

/// 安装 git hooks（post-commit/post-merge）；返回（新装/升级数量,
/// 任一 hook 文件最终是否存在）——第二值供总结语区分「已配置」与
/// 「未检测到 .git 目录」（v41：全部已最新时 installed=0 但 hook 可用，
/// 不再误报「未安装」）
///
/// v41 追加块语义（与用户既有 hook 共存，业界标记块惯例——husky 等
/// 工具同款思路）：
/// - 不存在 → 新建独立脚本
/// - 已存在且含追加块标记 → 只替换块区间（保留区间外用户内容）
/// - 已存在且含旧标记（v33/v37 独立脚本）→ 内容不同则整文件覆盖升级
/// - 已存在且无标记（用户/第三方自定义 hook）→ 尾部追加块（不覆盖）
/// - `.git/hooks` 不存在（非 git 仓库）→ 提示跳过（install 不因此失败）
/// - core.hooksPath 指向 .git/hooks 之外 → 提示（不失败）
fn install_hooks(project_root: &std::path::Path) -> Result<bool> {
    let hooks_dir = project_root.join(".git").join("hooks");
    if !hooks_dir.exists() {
        println!("未检测到 .git 目录，跳过 git hook 安装");
        return Ok(false);
    }
    if let Some(path) = detect_core_hooks_path(project_root) {
        // hooksPath 指向 .git/hooks 本身 = 等同默认，无影响；指向其他
        // 目录才提示（写入 .git/hooks 不会生效）
        let hooks_dir_abs = hooks_dir.canonicalize().unwrap_or_else(|_| hooks_dir.clone());
        let hooks_path_abs = std::path::Path::new(&path)
            .canonicalize()
            .unwrap_or_else(|_| std::path::PathBuf::from(&path));
        if hooks_path_abs != hooks_dir_abs {
            println!(
                "? 检测到 git core.hooksPath = {path}——hook 将从该目录加载，写入 .git/hooks 不会生效（可移除该配置或将其指向 .git/hooks）"
            );
        }
    }
    let content = hook_content();
    let block = hook_block();
    for hook_name in &["post-commit", "post-merge"] {
        let hook_path = hooks_dir.join(hook_name);
        if hook_path.exists() {
            let existing = std::fs::read_to_string(&hook_path)?;
            if hook_is_ours(&existing) {
                if existing.contains(HOOK_MARKER) {
                    // 追加块场景：只替换块区间，保留用户内容
                    let new_content = replace_hook_block(&existing, &block);
                    if new_content != existing {
                        write_hook(&hook_path, &new_content)?;
                        println!("✓ git {hook_name} hook 已升级（追加块已更新，用户内容保留）");
                    } else {
                        println!("✓ git {hook_name} hook 已是最新");
                    }
                } else if existing != content {
                    write_hook(&hook_path, &content)?;
                    println!("✓ git {hook_name} hook 已升级");
                } else {
                    println!("✓ git {hook_name} hook 已是最新");
                }
            } else {
                // 用户/第三方 hook：尾部追加块，保留原内容
                write_hook(&hook_path, &append_hook_block(&existing, &block))?;
                println!("✓ git {hook_name} hook 已追加 code-repo-wiki 块（原内容保留）");
            }
        } else {
            write_hook(&hook_path, &content)?;
            println!("✓ git {hook_name} hook 已安装");
        }
    }
    Ok(true)
}

/// 移除 git hooks（仅 code-repo-wiki 的；用户自定义 hook 保留）
///
/// v41：追加块场景剥离块区间（用户内容保留写回）；独立脚本场景删文件。
/// 判定与 install_hooks 同源（当前标记或 v37 旧标记——旧模板无 managed
/// 标记但含 repo-wiki 调用，同样识别，避免改名后旧 hook 残留静默失效）。
fn remove_hooks(project_root: &std::path::Path) -> Result<()> {
    let hooks_dir = project_root.join(".git").join("hooks");
    if !hooks_dir.exists() {
        return Ok(());
    }
    for hook_name in &["post-commit", "post-merge"] {
        let hook_path = hooks_dir.join(hook_name);
        if hook_path.exists() {
            let content = std::fs::read_to_string(&hook_path).unwrap_or_default();
            if hook_is_ours(&content) {
                if content.contains(HOOK_MARKER) {
                    // 追加块：剥离区间，用户内容保留
                    let remaining = strip_hook_block(&content);
                    if remaining.is_empty() {
                        std::fs::remove_file(&hook_path)?;
                    } else {
                        write_hook(&hook_path, &remaining)?;
                    }
                    println!("✓ git {hook_name} hook 已移除 code-repo-wiki 块（原内容保留）");
                } else {
                    std::fs::remove_file(&hook_path)?;
                    println!("✓ git {hook_name} hook 已移除");
                }
            }
        }
    }
    Ok(())
}

/// code-repo-wiki 卸载（v33 合并版）：移除全部集成痕迹（--force 确认）
///
/// root 为项目根（U02：--root 注入，与 install 对称）。
///
/// 清理集 = install 全集的反向（全部幂等，缺省即跳过）：
/// 1. OpenCode MCP 用户级全局条目（其他 server 保留）
/// 2. OpenCode 插件文件
/// 3. Claude MCP `~/.claude.json` 顶层 mcpServers 条目（其他键/其他 server
///    保留；空 mcpServers 保留文件——OAuth 会话等用户配置绝不动）
/// 4. Codex MCP 表（其他表/注释保留）
/// 5. AGENTS.md / CLAUDE.md wiki 块（无标记则跳过）
/// 6. git hooks（仅 code-repo-wiki 标记的删除；用户自定义 hook 保留）
///
/// 保留（设计如此，配置与数据属用户资产）：用户级 config.toml、
/// `.code-repo-wiki/` 产物数据。
pub fn uninstall(force: bool, root: &crate::project::ProjectRoot) -> Result<()> {
    let project_root = root.path();

    if !force {
        println!("警告: 卸载将移除 code-repo-wiki 集成配置（插件/MCP/hook/AGENTS.md 引用块）。");
        println!("保留：用户级 config.toml 与产物数据 .code-repo-wiki/（使用 --force 跳过确认）。");
        anyhow::bail!("请添加 --force 参数确认卸载");
    }

    // 1. OpenCode MCP（用户级全局）
    let opencode_mcp = crate::config::mcp::OpencodeMcp {
        config_path: crate::config::mcp::OpencodeMcp::global_path()?,
    };
    if opencode_mcp.remove("code-repo-wiki")? {
        println!("✓ OpenCode MCP 条目已移除（用户级全局——其他仓库如需继续使用请重新 install）");
    } else {
        println!("✓ OpenCode MCP 条目不存在，跳过");
    }

    // 2. OpenCode 插件（用户级配置根 + 旧版项目级产物迁移清理）
    let mut oc = crate::config::opencode::OpenCodeConfig::new(root)
        .context("读取 OpenCode 配置失败")?;
    oc.uninstall_plugin()?;
    oc.uninstall_plugin_file()?;
    println!("✓ OpenCode 插件已移除（用户级全局——所有仓库的 opencode 会话不再自动加载）");

    // 3. Claude MCP（用户级 ~/.claude.json User scope，v39）
    let claude = crate::config::mcp::ClaudeMcp {
        path: crate::config::mcp::ClaudeMcp::user_global_path()?,
    };
    if claude.remove("code-repo-wiki")? {
        println!("✓ Claude Code MCP 条目已移除（~/.claude.json——其他仓库如需继续使用请重新 install）");
    } else {
        println!("✓ Claude Code MCP 条目不存在，跳过（~/.claude.json）");
    }

    // 4. Codex MCP（~/.codex/config.toml）
    let codex = crate::config::mcp::CodexMcp {
        config_path: crate::config::mcp::CodexMcp::global_path()?,
    };
    if codex.remove("code-repo-wiki")? {
        println!("✓ Codex MCP 条目已移除（~/.codex/config.toml）");
    } else {
        println!("✓ Codex MCP 条目不存在，跳过（~/.codex/config.toml）");
    }

    // 5. AGENTS.md / CLAUDE.md wiki 块
    uninstall_wiki(root)?;

    // 6. git hooks
    remove_hooks(project_root)?;

    println!("✓ code-repo-wiki 卸载完成 (数据保留: .code-repo-wiki/ 与用户级配置)");
    Ok(())
}

/// wiki 引用块的起始标记（注入块的唯一边界；v37 改名后为 CODE-REPO-WIKI）
pub const WIKI_BLOCK_START: &str = "<!-- CODE-REPO-WIKI:START -->";

/// wiki 引用块的结束标记
pub const WIKI_BLOCK_END: &str = "<!-- CODE-REPO-WIKI:END -->";

/// v37 改名前的旧标记（REPO-WIKI）。升级兼容：inject 把旧块整体替换为新
/// 模板（迁移），remove 把新旧标记对一并删除——已注入旧块的仓库升级
/// 后不会留下双份块。
pub const LEGACY_WIKI_BLOCK_START: &str = "<!-- REPO-WIKI:START -->";

/// v37 改名前的旧结束标记
pub const LEGACY_WIKI_BLOCK_END: &str = "<!-- REPO-WIKI:END -->";

/// 渲染注入块模板（install 的 AGENTS.md 注入与 CLAUDE.md 注入共用）
///
/// 内容为中文 markdown 指针风格：只引产物路径与常用命令，不复制 wiki
/// 正文（避免与 LLM 生成的产物内容双份漂移）。以换行结尾，保证追加/
/// 替换后与相邻内容衔接干净。
///
/// 产物路径按实际配置渲染（U02）：`output_dir` 与 `lang` 来自目标仓库的
/// config.toml（output.dir / wiki.language）——此前模板硬编码 `wiki/` 与
/// `zh`，默认配置（output.dir=.code-repo-wiki、language 可改）下注入指引失配。
pub fn wiki_block_template(output_dir: &str, lang: &str) -> String {
    format!(
        "\
<!-- CODE-REPO-WIKI:START -->
本仓库使用 code-repo-wiki 维护可持续进化的项目 Wiki，产物位于 `{output_dir}/`。

## AI 代理使用指引

1. 先读 `{output_dir}/llms.txt` 定位目标页面（站点地图），再读
   `{output_dir}/wiki/{lang}/overview.md` 与 `{output_dir}/wiki/{lang}/architecture.md`
   建立全局认知，按需深入模块页；上下文预算充足时用 `{output_dir}/llms-full.txt`
   一次获得完整实体骨架。
2. 查找实体（函数/结构体/类）用 `code-repo-wiki search -q \"<关键词>\"`（支持
   text/semantic/hybrid 三引擎，hybrid 含调用链补全）。
3. 修改代码后运行 `code-repo-wiki update` 增量更新；`code-repo-wiki lint` 检查产物健康。
4. 知识沉淀：`code-repo-wiki note \"<记录>\"` 追加到 `{output_dir}/wiki/{lang}/_log.md`。
<!-- CODE-REPO-WIKI:END -->
"
    )
}

/// 文档中 wiki 标记对的状态
enum WikiBlockState {
    /// 完整标记对：START 所在行的行首偏移，END 所在行的行尾偏移（含换行）
    Both(usize, usize),
    /// 只出现一个标记（或顺序颠倒）：拒绝自动修复
    Half,
    /// 无任何标记
    None,
}

/// 定位文档中的 wiki 标记对（当前标记与 v37 旧标记都识别）
///
/// 标记对候选按「新标记优先」顺序探测：
/// - 新标记（CODE-REPO-WIKI）完整对 → 用它（升级替换的落点）
/// - 新标记无、旧标记（REPO-WIKI）完整对 → 用它（旧块迁移落点）
/// - 任一套只出现 START/END 之一，或顺序颠倒 → Half（不自动修复）
/// - 两套都无 → None（干净状态，可安全追加）
///
/// - Both: start 对齐到 START 行首、end 对齐到 END 行尾（含换行），
///   使"整块替换/删除"只触碰标记及其之间内容，不伤用户文本。
/// - Half: 半标记说明文件被人为改坏或与其他工具冲突，修补方向有歧义
///   （删哪半？补哪半？），显式报错让用户处理。
fn wiki_block_state(content: &str) -> WikiBlockState {
    // 探测顺序：新标记对优先，其次旧标记对；两套都存在时只处理新对
    // （旧对残留由 remove 循环删除清理，inject 不重复迁移）
    for (start_marker, end_marker) in
        [(WIKI_BLOCK_START, WIKI_BLOCK_END), (LEGACY_WIKI_BLOCK_START, LEGACY_WIKI_BLOCK_END)]
    {
        let start = content.find(start_marker);
        let end = content.find(end_marker);
        match (start, end) {
            (Some(s), Some(e)) if s < e => {
                let line_start = content[..s].rfind('\n').map_or(0, |i| i + 1);
                let line_end = content[e..].find('\n').map_or(content.len(), |i| e + i + 1);
                return WikiBlockState::Both(line_start, line_end);
            }
            (None, None) => continue,
            _ => return WikiBlockState::Half,
        }
    }
    WikiBlockState::None
}

/// 将 wiki 引用块注入文档文本（纯函数，不含 I/O，install 的 AGENTS.md/CLAUDE.md 注入共用）
///
/// 幂等策略：
/// - 完整标记对 → 整块替换（只动标记之间内容，保留用户其他内容）；
/// - 无标记 → 文件尾 trim 后追加（与已有内容之间留一个空行）；
/// - 只有一半标记 → 报错（理由见 `wiki_block_state`）。
pub fn inject_wiki_block(content: &str, block: &str) -> Result<String> {
    match wiki_block_state(content) {
        WikiBlockState::Both(start, end) => {
            let mut out = String::with_capacity(content.len() + block.len());
            out.push_str(&content[..start]);
            out.push_str(block);
            out.push_str(&content[end..]);
            Ok(out)
        }
        WikiBlockState::None => {
            // 追加：trim 掉尾部空白后接一个空行再放块，避免与用户内容粘连
            let trimmed = content.trim_end();
            let mut out = String::with_capacity(content.len() + block.len() + 2);
            out.push_str(trimmed);
            if !trimmed.is_empty() {
                out.push_str("\n\n");
            }
            out.push_str(block);
            Ok(out)
        }
        WikiBlockState::Half => {
            anyhow::bail!("检测到不完整的 wiki 标记对（只出现 {WIKI_BLOCK_START} 或 {WIKI_BLOCK_END} 之一，或顺序颠倒），拒绝修改，请人工检查文件")
        }
    }
}

/// 从文档文本移除 wiki 引用块（纯函数，不含 I/O）
///
/// 返回 `None` 表示无标记（未安装）；`Some` 为移除后的内容。
/// 半标记同样报错（与注入一致：不自动修复）。
///
/// 循环删除：新标记对删完后可能还残留旧标记对（v37 改名前的块），
/// 一并清掉——两套对都处理完才返回，保证卸载彻底。
pub fn remove_wiki_block(content: &str) -> Result<Option<String>> {
    let mut out = content.to_string();
    let mut removed = false;
    // 最多两轮：新对 + 旧对各一轮；每轮删除后重扫（对位置随删除前移）
    for _ in 0..2 {
        match wiki_block_state(&out) {
            WikiBlockState::Both(start, end) => {
                let mut next = String::with_capacity(out.len() - (end - start));
                next.push_str(&out[..start]);
                next.push_str(&out[end..]);
                out = next;
                removed = true;
            }
            WikiBlockState::None => break,
            WikiBlockState::Half => {
                anyhow::bail!("检测到不完整的 wiki 标记对（只出现 {WIKI_BLOCK_START} 或 {WIKI_BLOCK_END} 之一，或顺序颠倒），拒绝修改，请人工检查文件")
            }
        }
    }
    Ok(if removed { Some(out) } else { None })
}

/// 向单个文件写入 wiki 引用块（读 → 注入 → 原子写）
fn write_wiki_block(path: &Path, block: &str) -> Result<()> {
    // 文件不存在视为空文档（正常创建路径），读取失败才显式报错
    let content = if path.exists() {
        std::fs::read_to_string(path)
            .with_context(|| format!("读取文件失败: {}", path.display()))?
    } else {
        String::new()
    };
    let new_content = inject_wiki_block(&content, block)?;
    crate::fs::write_file_atomic(path, &new_content)
}

/// 移除单个文件中的 wiki 引用块；返回是否实际移除
fn remove_wiki_block_from_file(path: &Path) -> Result<bool> {
    if !path.exists() {
        return Ok(false);
    }
    let content = std::fs::read_to_string(path)
        .with_context(|| format!("读取文件失败: {}", path.display()))?;
    match remove_wiki_block(&content)? {
        Some(new_content) => {
            crate::fs::write_file_atomic(path, &new_content)?;
            Ok(true)
        }
        None => Ok(false),
    }
}

/// install: 向项目根 AGENTS.md 注入 wiki 引用块（--claude 时同步写 CLAUDE.md）
///
/// 文件不存在则创建；已存在完整标记对则整块替换（只动标记之间内容）；
/// 半标记报错（不修，理由见 `wiki_block_state`）。
///
/// 注入块按目标仓库配置渲染（U02）：读 `root/config.toml` 取
/// output.dir 与 wiki.language；配置缺失（首次运行/未 install）时回退默认值
/// (".code-repo-wiki", "zh") 不报错——wiki 块缺失比注入失败更隐蔽。
pub fn install_wiki(root: &crate::project::ProjectRoot, also_claude: bool) -> Result<()> {
    // 渲染配置走完整配置链（v41 修复：与运行命令同源——项目级 config.toml
    // 字段级合并覆盖用户级 ~/.code-repo-wiki/config.toml；两者皆无时自动
    // 创建用户级默认模板）。此前只读项目级单文件，用户级配置存在时仍误报
    // 「未找到有效配置」，且渲染值忽略用户级偏好（如 wiki.language）。
    let (_, cfg) = match crate::config::load_default_config(root) {
        Ok(pair) => pair,
        // 配置畸形（如 TOML 语法错误）：按默认值继续注入——wiki 块缺失
        // 比注入失败更隐蔽（U02 语义保持）
        Err(e) => {
            println!(
                "提示: 配置解析失败（{e}），注入块按默认产物路径 (.code-repo-wiki / zh) 渲染"
            );
            let cfg = crate::config::load_config(&root.join(Path::new(crate::config::PROJECT_CONFIG_FILE)))
                .unwrap_or_else(|_| crate::config::schema::WikiConfig::default());
            let output_dir = cfg.output_dir().to_string_lossy().into_owned();
            let lang = cfg.wiki.language;
            let block = wiki_block_template(&output_dir, &lang);
            let agents_path = root.join(Path::new("AGENTS.md"));
            write_wiki_block(&agents_path, &block)?;
            println!("✓ wiki 引用块已注入 {}", agents_path.display());
            if also_claude {
                let claude_path = root.join(Path::new("CLAUDE.md"));
                write_wiki_block(&claude_path, &block)?;
                println!("✓ wiki 引用块已注入 {}", claude_path.display());
            }
            return Ok(());
        }
    };
    let output_dir = cfg.output_dir().to_string_lossy().into_owned();
    let lang = cfg.wiki.language;
    let block = wiki_block_template(&output_dir, &lang);
    let agents_path = root.join(Path::new("AGENTS.md"));
    write_wiki_block(&agents_path, &block)?;
    println!("✓ wiki 引用块已注入 {}", agents_path.display());
    if also_claude {
        let claude_path = root.join(Path::new("CLAUDE.md"));
        write_wiki_block(&claude_path, &block)?;
        println!("✓ wiki 引用块已注入 {}", claude_path.display());
    }
    Ok(())
}

/// uninstall: 移除 AGENTS.md 中的 wiki 引用块（含标记本身）
///
/// - AGENTS.md 无标记 → 提示"未安装"，退出码 0（幂等，与卸载语义一致）；
/// - 半标记 → 报错（不修）；
/// - CLAUDE.md 只在含标记对时清理（install --also-claude 的对称卸载），
///   从未注入过则静默跳过——CLAUDE.md 不被无标记情况下改动。
pub fn uninstall_wiki(root: &crate::project::ProjectRoot) -> Result<()> {
    let agents_path = root.join(Path::new("AGENTS.md"));
    if remove_wiki_block_from_file(&agents_path)? {
        println!("✓ wiki 引用块已从 {} 移除", agents_path.display());
    } else {
        println!("AGENTS.md 未安装 wiki 引用块，无需卸载");
    }
    let claude_path = root.join(Path::new("CLAUDE.md"));
    if remove_wiki_block_from_file(&claude_path)? {
        println!("✓ wiki 引用块已从 {} 移除", claude_path.display());
    }
    Ok(())
}

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

    /// 注入测试用的模板块（默认产物路径形态，模板函数化后的断言锚点）
    fn test_template() -> String {
        wiki_block_template(".code-repo-wiki", "zh")
    }

    /// append_note 追加式日志：同一日期节内序号递增；两次调用不覆盖历史
    #[test]
    fn test_append_note_increments_sequence() {
        let dir = std::env::temp_dir().join(format!(
            "code_repo_wiki_note_{}",
            std::process::id()
        ));
        let _ = std::fs::remove_dir_all(&dir);
        std::fs::create_dir_all(&dir).unwrap();

        append_note(&dir, "zh", "第一条记录").unwrap();
        append_note(&dir, "zh", "第二条记录").unwrap();

        let log = std::fs::read_to_string(dir.join("wiki").join("zh").join("_log.md")).unwrap();
        assert!(log.contains("## "), "应含日期节");
        assert!(log.contains("- 1. 第一条记录"), "第一条应编号 1, 实际: {log}");
        assert!(log.contains("- 2. 第二条记录"), "第二条应编号 2, 实际: {log}");
        assert_eq!(
            log.matches("- ").count(),
            2,
            "应恰好 2 条记录, 实际: {log}"
        );

        let _ = std::fs::remove_dir_all(&dir);
    }

    /// 空内容拒绝写入（显式报错，不产生空记录）
    #[test]
    fn test_append_note_rejects_empty() {
        let dir = std::env::temp_dir().join(format!(
            "code_repo_wiki_note_empty_{}",
            std::process::id()
        ));
        let _ = std::fs::remove_dir_all(&dir);
        assert!(append_note(&dir, "zh", "   ").is_err(), "空内容应报错");
        let _ = std::fs::remove_dir_all(&dir);
    }

    // ==================== wiki 引用块注入/移除 ====================

    /// 全新注入：空文档 → 追加完整标记对，结果恰等于模板本身
    #[test]
    fn test_inject_wiki_block_fresh() {
        let out = inject_wiki_block("", &test_template()).unwrap();
        assert_eq!(out, test_template(), "空文档注入结果应等于模板本身");
        assert!(out.contains(WIKI_BLOCK_START) && out.contains(WIKI_BLOCK_END));
    }

    /// 幂等替换：已含完整标记对 → 旧块整体替换为模板，用户前后内容保留
    #[test]
    fn test_inject_wiki_block_replaces_existing() {
        let before =
            "用户头部\n\n<!-- CODE-REPO-WIKI:START -->\n旧块内容\n<!-- CODE-REPO-WIKI:END -->\n\n用户尾部\n";
        let out = inject_wiki_block(before, &test_template()).unwrap();
        assert!(out.starts_with("用户头部\n\n"), "用户头部应保留, 实际: {out}");
        assert!(out.ends_with("用户尾部\n"), "用户尾部应保留, 实际: {out}");
        assert!(out.contains(&test_template()), "旧块应被替换为模板, 实际: {out}");
        assert!(!out.contains("旧块内容"), "旧块内容应被替换掉, 实际: {out}");
    }

    /// v37 旧标记迁移：含旧标记（REPO-WIKI）完整块 → 同样整体替换为新模板
    /// （改名前的仓库升级路径，块标记随之换代）
    #[test]
    fn test_inject_wiki_block_migrates_legacy_marker() {
        let before =
            "用户头部\n\n<!-- REPO-WIKI:START -->\n旧名块内容\n<!-- REPO-WIKI:END -->\n用户尾部\n";
        let out = inject_wiki_block(before, &test_template()).unwrap();
        assert!(out.contains(WIKI_BLOCK_START) && out.contains(WIKI_BLOCK_END));
        assert!(
            !out.contains("<!-- REPO-WIKI:START -->") && !out.contains("<!-- REPO-WIKI:END -->"),
            "旧标记应随迁移消失, 实际: {out}"
        );
        assert!(!out.contains("旧名块内容"), "旧块内容应被替换掉, 实际: {out}");
        assert!(out.contains("用户头部") && out.contains("用户尾部"), "用户内容应保留: {out}");
    }

    /// 幂等：同一文档注入两次 → 结果一致（第二次走替换路径）
    #[test]
    fn test_inject_wiki_block_twice_stable() {
        let first = inject_wiki_block("头部\n", &test_template()).unwrap();
        let second = inject_wiki_block(&first, &test_template()).unwrap();
        assert_eq!(first, second, "重复注入应幂等（内容不变）");
    }

    /// 半标记报错：只有 START / 只有 END / 顺序颠倒 → 均显式报错
    /// （当前标记与 v37 旧标记两套都要检）
    #[test]
    fn test_inject_wiki_block_half_marker_errors() {
        let cases = [
            "# 标题\n<!-- CODE-REPO-WIKI:START -->\n",
            "<!-- CODE-REPO-WIKI:END -->\n",
            "<!-- CODE-REPO-WIKI:END -->\n<!-- CODE-REPO-WIKI:START -->\n",
            "# 标题\n<!-- REPO-WIKI:START -->\n",
            "<!-- REPO-WIKI:END -->\n",
        ];
        for case in cases {
            let err = inject_wiki_block(case, &test_template()).unwrap_err();
            assert!(err.to_string().contains("不完整"), "半标记应报错: {err}");
        }
    }

    /// 保留用户内容：无标记追加场景下用户内容完整保留在块之前
    #[test]
    fn test_inject_wiki_block_preserves_user_content() {
        let before = "# 我的项目\n\n这是用户写的说明。\n";
        let out = inject_wiki_block(before, &test_template()).unwrap();
        let marker_idx = out.find(WIKI_BLOCK_START).unwrap();
        assert_eq!(
            &out[..marker_idx],
            "# 我的项目\n\n这是用户写的说明。\n\n",
            "块前应只有用户内容加一个空行"
        );
    }

    /// remove：无标记 → None（未安装）
    #[test]
    fn test_remove_wiki_block_not_installed() {
        assert!(remove_wiki_block("# 标题\n").unwrap().is_none());
    }

    /// remove：完整标记对 → 移除标记及内容，用户前后内容保留
    #[test]
    fn test_remove_wiki_block_removes_only_block() {
        let content =
            "用户头部\n\n<!-- CODE-REPO-WIKI:START -->\n块内容\n<!-- CODE-REPO-WIKI:END -->\n用户尾部\n";
        let out = remove_wiki_block(content).unwrap().unwrap();
        assert!(!out.contains(WIKI_BLOCK_START) && !out.contains(WIKI_BLOCK_END), "标记应被移除: {out}");
        assert!(out.contains("用户头部") && out.contains("用户尾部"), "用户内容应保留: {out}");
    }

    /// remove：新旧标记块并存（升级残留的双块）→ 一并移除，用户内容保留
    #[test]
    fn test_remove_wiki_block_removes_both_marker_generations() {
        let content = "用户头部\n\n<!-- REPO-WIKI:START -->\n旧名块\n<!-- REPO-WIKI:END -->\n\n<!-- CODE-REPO-WIKI:START -->\n新块\n<!-- CODE-REPO-WIKI:END -->\n用户尾部\n";
        let out = remove_wiki_block(content).unwrap().unwrap();
        assert!(
            !out.contains("REPO-WIKI") && !out.contains("CODE-REPO-WIKI"),
            "两代标记都应被移除, 实际: {out}"
        );
        assert!(out.contains("用户头部") && out.contains("用户尾部"), "用户内容应保留: {out}");
    }

    /// remove：半标记同样报错（当前标记与旧标记都检）
    #[test]
    fn test_remove_wiki_block_half_marker_errors() {
        let err = remove_wiki_block("<!-- CODE-REPO-WIKI:START -->\n").unwrap_err();
        assert!(err.to_string().contains("不完整"), "半标记应报错: {err}");
        let err = remove_wiki_block("<!-- REPO-WIKI:START -->\n").unwrap_err();
        assert!(err.to_string().contains("不完整"), "旧标记半标记应报错: {err}");
    }
}