Skill Manager

{
  "_note": "Skill Manager 注册表示例 - 复制此文件为 skill-registry.json 使用",
  "example-local-skill": {
    "name": "example-local-skill",
    "source": "/path/to/local/skills/example-local-skill",
    "install_type": "local",
    "installed_at": "2026-04-08T10:00:00+08:00",
    "last_updated": "2026-04-08T10:00:00+08:00",
    "last_check_at": null,
    "installed_version": "1.0.0",
    "current_version": "1.0.0",
    "latest_version": null,
    "install_commit": null,
    "install_branch": null,
    "remote_url": null,
    "description": "示例本地安装的 Skill"
  },
  "example-remote-skill": {
    "name": "example-remote-skill",
    "source": "https://github.com/owner/skill-repo",
    "install_type": "remote",
    "installed_at": "2026-04-08T10:00:00+08:00",
    "last_updated": "2026-04-08T10:00:00+08:00",
    "last_check_at": "2026-04-15T10:00:00+08:00",
    "installed_version": "1.0.0",
    "current_version": "1.0.0",
    "latest_version": "1.2.0",
    "install_commit": "a1b2c3d",
    "install_branch": "main",
    "remote_url": "https://github.com/owner/skill-repo",
    "description": "示例 GitHub 安装的 Skill"
  }
}

MIT License

Copyright (c) 2025 杨卫薪律师（微信ywxlaw）

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

#!/bin/bash

# Skill Manager - Auto Update Check
# 检查超过阈值的远程 Skill 更新状态
# 仅在发现更新时输出，否则静默退出

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

if ! command -v python3 &> /dev/null; then
    exit 0
fi

RECORD_SCRIPT="$SCRIPT_DIR/record.py"
if [ ! -f "$RECORD_SCRIPT" ]; then
    exit 0
fi

THRESHOLD="${SKILL_MANAGER_CHECK_THRESHOLD:-7}"

python3 "$RECORD_SCRIPT" auto-check --threshold "$THRESHOLD" 2>/dev/null

#!/bin/bash

# Skill Manager - Check Updates Script
# 检查所有已安装 Skills 的更新状态

# 获取脚本所在目录
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
MANAGER_DIR="$(dirname "$SCRIPT_DIR")"

# 检查 Python 是否可用
if ! command -v python3 &> /dev/null; then
    echo "❌ 需要 Python 3 来运行更新检查"
    exit 1
fi

RECORD_SCRIPT="$SCRIPT_DIR/record.py"
if [ ! -f "$RECORD_SCRIPT" ]; then
    echo "❌ 找不到记录模块: $RECORD_SCRIPT"
    exit 1
fi

# 执行检查
echo "🔍 正在检查 Skill 更新..."
echo ""

python3 "$RECORD_SCRIPT" check-all

#!/bin/bash

# Skill & Command Manager - Install Script
# 安装或同步外部 skills/commands 到本地 Agent 配置目录
# 自动检测所有 Agent 目录 (.codex/.claude/.openclaw) 并批量安装

set -e

# Parse arguments: support --target flag for explicit target directory
SOURCE=""
TARGET_OVERRIDE=""
while [ $# -gt 0 ]; do
    case "$1" in
        --target|-t)
            if [ -z "${2:-}" ]; then
                echo "❌ 错误: --target 需要指定目录路径"
                exit 1
            fi
            TARGET_OVERRIDE="$2"
            shift 2
            ;;
        -h|--help)
            echo "用法: $0 [选项] <source>"
            echo ""
            echo "选项:"
            echo "  --target, -t <dir>  指定目标 Agent 配置目录"
            echo ""
            echo "示例:"
            echo "  $0 ~/skills/pdf-tool"
            echo "  $0 --target /path/to/project/.claude ~/skills/pdf-tool"
            exit 0
            ;;
        *)
            SOURCE="$1"
            shift
            ;;
    esac
done

# 保存调用者的原始工作目录（关键：用于定位项目 Agent 配置目录）
ORIGINAL_PWD="$PWD"

# Apply --target override
if [ -n "$TARGET_OVERRIDE" ]; then
    export SKILL_MANAGER_TARGET_DIR="$TARGET_OVERRIDE"
fi
# 获取脚本所在目录
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
MANAGER_DIR="$(dirname "$SCRIPT_DIR")"
TARGET_HELPER="$SCRIPT_DIR/target.sh"

if [ -f "$TARGET_HELPER" ]; then
    # shellcheck source=target.sh
    source "$TARGET_HELPER"
else
    echo "❌ 错误: 找不到目标目录识别模块: $TARGET_HELPER"
    exit 1
fi

# 安装记录函数 - 记录 Skill 安装到注册表
record_install() {
    local skill_name="$1"
    local source_url="$2"
    local target_path="$3"

    # 调用 Python 记录模块
    if command -v python3 &> /dev/null; then
        RECORD_SCRIPT="$SCRIPT_DIR/record.py"
        if [ -f "$RECORD_SCRIPT" ]; then
            python3 "$RECORD_SCRIPT" install "$skill_name" "$source_url" --path "$target_path" --install-type local 2>/dev/null || true
        fi
    fi
}

# 检测源类型（skill 或 command）
detect_source_type() {
    local src="$1"

    # 如果是文件
    if [ -f "$src" ]; then
        if [[ "$src" =~ \.md$ ]]; then
            echo "command"
        else
            echo "unknown"
        fi
    # 如果是目录
    elif [ -d "$src" ]; then
        # 优先检查是否为 skill（包含 SKILL.md 或 Agent 配置目录等）
        if [ -f "$src/SKILL.md" ] || [ -f "$src/skill.md" ] || [ -d "$src/.codex" ] || [ -d "$src/.claude" ] || [ -d "$src/.openclaw" ] || [ -d "$src/.agents" ] || [ -d "$src/.agent" ]; then
            echo "skill"
        # 检查是否为 command 集合目录（包含多个 .md 文件，但不包含 SKILL.md）
        else
            local md_count=$(find "$src" -maxdepth 1 -name "*.md" -type f 2>/dev/null | wc -l | tr -d ' ')
            if [ "$md_count" -gt 0 ]; then
                echo "command-collection"
            else
                echo "unknown"
            fi
        fi
    else
        echo "unknown"
    fi
}

# 检查是否为 skills 集合目录
is_skills_collection() {
    local dir="$1"
    local found_skills=0

    for item in "$dir"/*; do
        if [ -d "$item" ]; then
            if [ -f "$item/SKILL.md" ] || [ -f "$item/skill.md" ] || [ -d "$item/.codex" ] || [ -d "$item/.claude" ] || [ -d "$item/.openclaw" ]; then
                ((found_skills++))
            fi
        fi
    done

    [ "$found_skills" -gt 1 ]
}

# 检查是否为 commands 集合目录
# 注意：必须排除包含 SKILL.md 的 skill 目录
is_commands_collection() {
    local dir="$1"
    local found_commands=0

    # 如果目录包含 SKILL.md，则不是 commands 集合
    if [ -f "$dir/SKILL.md" ] || [ -f "$dir/skill.md" ] || [ -d "$dir/.codex" ] || [ -d "$dir/.claude" ] || [ -d "$dir/.openclaw" ]; then
        return 1
    fi

    for item in "$dir"/*; do
        if [ -f "$item" ] && [[ "$item" =~ \.md$ ]]; then
            # 排除 SKILL.md/skill.md 文件
            local basename=$(basename "$item")
            if [ "$basename" != "SKILL.md" ] && [ "$basename" != "skill.md" ]; then
                ((found_commands++))
            fi
        fi
    done

    [ "$found_commands" -gt 1 ]
}

# 检查参数
if [ -z "$SOURCE" ]; then
    echo "❌ 错误: 请提供源路径或 URL"
    echo ""
    echo "使用方法:"
    echo "  $0 <本地路径 | github-url | owner/repo>"
    echo ""
    echo "示例:"
    echo "  本地单个 skill/command:  $0 ~/my-skills/pdf-tool"
    echo "  本地 skills 集合:        $0 ~/skills/"
    echo "  本地 commands 集合:      $0 ~/commands/"
    echo "  GitHub 仓库:             $0 owner/repo"
    echo "  GitHub 子目录:           $0 owner/repo/branch/path/to/skills"
    exit 1
fi

# ---- 检测来源类型 ----

if [[ "$SOURCE" =~ ^https?://github\.com/([^/]+)/([^/]+)/blob/([^/]+)/(.+)$ ]]; then
    # GitHub URL 到子目录 (blob 格式)
    OWNER="${BASH_REMATCH[1]}"
    REPO="${BASH_REMATCH[2]}"
    BRANCH="${BASH_REMATCH[3]}"
    SUBPATH="${BASH_REMATCH[4]}"
    SOURCE_TYPE="github-subdir"
    CLONE_URL="https://github.com/$OWNER/$REPO"
elif [[ "$SOURCE" =~ ^https?://github\.com/([^/]+)/([^/]+)/tree/([^/]+)/(.+)$ ]]; then
    # GitHub URL 到子目录 (tree 格式)
    OWNER="${BASH_REMATCH[1]}"
    REPO="${BASH_REMATCH[2]}"
    BRANCH="${BASH_REMATCH[3]}"
    SUBPATH="${BASH_REMATCH[4]}"
    SOURCE_TYPE="github-subdir"
    CLONE_URL="https://github.com/$OWNER/$REPO"
elif [[ "$SOURCE" =~ ^https?://github\.com/([^/]+)/([^/]+)(\.git)?/?$ ]]; then
    # GitHub 仓库根目录
    OWNER="${BASH_REMATCH[1]}"
    REPO="${BASH_REMATCH[2]}"
    SOURCE_TYPE="github"
    CLONE_URL="https://github.com/$OWNER/$REPO"
elif [[ "$SOURCE" =~ ^([^/]+)/([^/]+)(/(.+))?$ ]]; then
    # 可能是 GitHub 简写格式，需要进一步检查
    # 如果路径不存在，则认为是 GitHub 格式
    if [ ! -e "$SOURCE" ]; then
        OWNER="${BASH_REMATCH[1]}"
        REPO="${BASH_REMATCH[2]}"
        if [ -n "${BASH_REMATCH[4]}" ]; then
            SUBPATH="${BASH_REMATCH[4]}"
            SOURCE_TYPE="github-subdir"
            CLONE_URL="https://github.com/$OWNER/$REPO"
        else
            SOURCE_TYPE="github"
            CLONE_URL="https://github.com/$OWNER/$REPO"
        fi
    else
        SOURCE_TYPE="local"
    fi
else
    # 本地路径
    SOURCE_TYPE="local"
fi

# ---- 检测所有 Agent 配置目录 ----

FALLBACK_AGENT_DIR="$(find_agent_config_dir "$ORIGINAL_PWD" "$(find_agent_config_dir "$MANAGER_DIR" "$PWD/.claude")")"

ALL_AGENT_DIRS=()
while IFS= read -r dir; do
    ALL_AGENT_DIRS+=("$dir")
done < <(find_all_agent_config_dirs "$ORIGINAL_PWD" "$FALLBACK_AGENT_DIR")

if [ ${#ALL_AGENT_DIRS[@]} -eq 0 ]; then
    echo "❌ 错误: 未找到任何 Agent 配置目录 (.codex/.claude/.openclaw)"
    exit 1
fi

# Safety: if target would be a global config root, try git-based project rescue
_is_global_config_root() {
    local dir="$1"
    local _home="${HOME:-/Users/${USER}}"
    case "$dir" in
        "$_home/.codex"| "$_home/.claude"| "$_home/.openclaw"| "$_home/.agents"| "$_home/.agent") return 0 ;;
    esac
    return 1
}

if [ -z "${SKILL_MANAGER_TARGET_DIR:-}" ] && [ ${#ALL_AGENT_DIRS[@]} -gt 0 ]; then
    _only_global=true
    for _dir in "${ALL_AGENT_DIRS[@]}"; do
        if ! _is_global_config_root "$_dir"; then
            _only_global=false
            break
        fi
    done

    if [ "$_only_global" = true ]; then
        # Try git-based project rescue
        _git_root="$(git rev-parse --show-toplevel 2>/dev/null || true)"
        _rescued=false
        if [ -n "$_git_root" ] && ! _is_global_config_root "$_git_root" && [ "$_git_root" != "$HOME" ]; then
            for _cfg in .codex .claude .openclaw .agents .agent; do
                if [ -d "$_git_root/$_cfg" ]; then
                    echo "🔄 检测到从全局配置目录调用，已通过 git 发现项目: $_git_root"
                    echo ""
                    ALL_AGENT_DIRS=("$_git_root/$_cfg")
                    _rescued=true
                    break
                fi
            done
        fi

        if [ "$_rescued" = false ]; then
            echo "⚠️  目标为全局配置目录 (${ALL_AGENT_DIRS[*]})"
            echo "   如需安装到项目目录，请使用: $0 --target <project/.claude> <source>"
            echo ""
        fi
    fi
fi

# 显示检测到的目录
AGENT_NAMES=()
for dir in "${ALL_AGENT_DIRS[@]}"; do
    AGENT_NAMES+=($(basename "$dir"))
done
echo "🔍 检测到 ${#ALL_AGENT_DIRS[@]} 个 Agent 配置目录: ${AGENT_NAMES[*]}"
echo ""

# ---- GitHub 预处理：克隆到临时目录（只克隆一次）----

TEMP_CLONE_DIR=""
INSTALL_COMMIT=""
INSTALL_BRANCH=""
GH_SKILL_NAME=""

if [ "$SOURCE_TYPE" = "github-subdir" ] || [ "$SOURCE_TYPE" = "github" ]; then
    if [ "$SOURCE_TYPE" = "github-subdir" ]; then
        GH_SKILL_NAME=$(basename "$SUBPATH")
    else
        GH_SKILL_NAME="$REPO"
    fi

    TEMP_CLONE_DIR=$(mktemp -d)

    if [ "$SOURCE_TYPE" = "github-subdir" ]; then
        echo "📦 正在从 GitHub 获取子目录..."
        echo "  仓库: $CLONE_URL"
        echo "  路径: $SUBPATH"

        cd "$TEMP_CLONE_DIR"
        git init -q
        git remote add origin "$CLONE_URL"
        git config core.sparseCheckout true
        echo "$SUBPATH" > .git/info/sparse-checkout
        git fetch --depth 1 origin "${BRANCH:-main}" -q 2>/dev/null || {
            echo "❌ 错误: 无法从 GitHub 获取"
            cd - > /dev/null
            rm -rf "$TEMP_CLONE_DIR"
            exit 1
        }
        git checkout "${BRANCH:-main}" -q

        INSTALL_COMMIT=$(git rev-parse --short HEAD 2>/dev/null || echo "")
        INSTALL_BRANCH="${BRANCH:-main}"

        cd - > /dev/null

        # 移动到临时目录内的固定位置（仅当源和目标不同时，避免单段路径 mv 到自身内部）
        if [ "$TEMP_CLONE_DIR/$SUBPATH" != "$TEMP_CLONE_DIR/$GH_SKILL_NAME" ]; then
            mv "$TEMP_CLONE_DIR/$SUBPATH" "$TEMP_CLONE_DIR/$GH_SKILL_NAME"
        fi
    else
        echo "📦 正在从 GitHub 克隆..."
        echo "  仓库: $CLONE_URL"

        git clone --depth 1 -q "$CLONE_URL" "$TEMP_CLONE_DIR/$GH_SKILL_NAME" 2>/dev/null || {
            echo "❌ 错误: 无法从 GitHub 克隆"
            rm -rf "$TEMP_CLONE_DIR"
            exit 1
        }

        INSTALL_COMMIT=$(cd "$TEMP_CLONE_DIR/$GH_SKILL_NAME" && git rev-parse --short HEAD 2>/dev/null || echo "")
        INSTALL_BRANCH=$(cd "$TEMP_CLONE_DIR/$GH_SKILL_NAME" && git branch --show-current 2>/dev/null || echo "main")

        # 删除 .git 目录
        rm -rf "$TEMP_CLONE_DIR/$GH_SKILL_NAME/.git"
    fi

    echo "✓ GitHub 源准备完成"
    echo ""
fi

# ---- 安装到每个 Agent 目录 ----

install_count=0
success_dirs=()
fail_count=0

for AGENT_DIR in "${ALL_AGENT_DIRS[@]}"; do
    agent_name=$(basename "$AGENT_DIR")
    SKILLS_DIR="$AGENT_DIR/skills"
    COMMANDS_DIR="$AGENT_DIR/commands"

    echo "───────────────────────────────────"
    echo "📦 安装到 $agent_name"
    echo "───────────────────────────────────"

    # ---- 本地来源 ----
    if [ "$SOURCE_TYPE" = "local" ]; then
        DETECTED_TYPE=$(detect_source_type "$SOURCE")

        if [ "$DETECTED_TYPE" = "unknown" ]; then
            if [ ! -e "$SOURCE" ]; then
                echo "❌ 错误: 找不到源: $SOURCE"
            else
                echo "❌ 错误: 无法识别源类型，请确保是 skill 目录或 command .md 文件"
            fi
            ((fail_count++)) || true
            echo ""
            continue
        fi

        # 处理单个 command 文件
        if [ "$DETECTED_TYPE" = "command" ]; then
            COMMAND_NAME=$(basename "$SOURCE" .md)
            TARGET_PATH="$COMMANDS_DIR/$COMMAND_NAME.md"

            mkdir -p "$COMMANDS_DIR"

            if [ -L "$TARGET_PATH" ]; then
                echo "⚠ 发现现有符号链接，正在移除..."
                rm "$TARGET_PATH"
            elif [ -f "$TARGET_PATH" ]; then
                if [ "$TARGET_PATH" -ef "$SOURCE" ]; then
                    echo "✓ 已指向相同文件"
                    ((install_count++)) || true
                    success_dirs+=("$agent_name")
                    echo ""
                    continue
                fi
                echo "⚠ 目标已存在，正在备份到 ${TARGET_PATH}.backup..."
                mv "$TARGET_PATH" "${TARGET_PATH}.backup"
            fi

            echo "🔗 正在创建 command 符号链接..."
            ln -s "$SOURCE" "$TARGET_PATH"
            echo "✓ 已链接 command: $TARGET_PATH -> $SOURCE"
            ((install_count++)) || true
            success_dirs+=("$agent_name")
            echo ""
            continue
        fi

        # 处理目录
        if [ ! -d "$SOURCE" ]; then
            echo "❌ 错误: 找不到源目录: $SOURCE"
            ((fail_count++)) || true
            echo ""
            continue
        fi

        # 检查是否为 skills 集合目录
        if is_skills_collection "$SOURCE"; then
            local_count=0
            for skill_dir in "$SOURCE"/*; do
                if [ -d "$skill_dir" ]; then
                    skill_name=$(basename "$skill_dir")

                    if [ -f "$skill_dir/SKILL.md" ] || [ -f "$skill_dir/skill.md" ] || [ -d "$skill_dir/.codex" ] || [ -d "$skill_dir/.claude" ] || [ -d "$skill_dir/.openclaw" ]; then
                        target_path="$SKILLS_DIR/$skill_name"
                        mkdir -p "$SKILLS_DIR"

                        if [ -L "$target_path" ]; then
                            rm "$target_path"
                        elif [ -d "$target_path" ]; then
                            if [ "$target_path" -ef "$skill_dir" ]; then
                                continue
                            fi
                            rm -rf "${target_path}.backup"
                            mv "$target_path" "${target_path}.backup"
                        fi

                        ln -s "$skill_dir" "$target_path"
                        echo "  ✓ 已链接: $skill_name"
                        ((local_count++)) || true
                    fi
                fi
            done

            echo "✓ 已安装 $local_count 个 skills"
            ((install_count++)) || true
            success_dirs+=("$agent_name")
            echo ""
            continue
        fi

        # 检查是否为 commands 集合目录
        if is_commands_collection "$SOURCE"; then
            local_count=0
            for cmd_file in "$SOURCE"/*.md; do
                if [ -f "$cmd_file" ]; then
                    cmd_name=$(basename "$cmd_file" .md)
                    target_path="$COMMANDS_DIR/$cmd_name.md"
                    mkdir -p "$COMMANDS_DIR"

                    if [ -L "$target_path" ]; then
                        rm "$target_path"
                    elif [ -f "$target_path" ]; then
                        if [ "$target_path" -ef "$cmd_file" ]; then
                            continue
                        fi
                        mv "$target_path" "${target_path}.backup"
                    fi

                    ln -s "$cmd_file" "$target_path"
                    echo "  ✓ 已链接: $cmd_name"
                    ((local_count++)) || true
                fi
            done

            echo "✓ 已安装 $local_count 个 commands"
            ((install_count++)) || true
            success_dirs+=("$agent_name")
            echo ""
            continue
        fi

        # 单个本地 skill - 使用符号链接
        if [ "$DETECTED_TYPE" = "skill" ]; then
            SKILL_NAME=$(basename "$SOURCE")
            TARGET_PATH="$SKILLS_DIR/$SKILL_NAME"

            mkdir -p "$SKILLS_DIR"

            if [ -L "$TARGET_PATH" ]; then
                echo "⚠ 发现现有符号链接，正在移除..."
                rm "$TARGET_PATH"
            elif [ -d "$TARGET_PATH" ]; then
                if [ "$TARGET_PATH" -ef "$SOURCE" ]; then
                    echo "✓ 已指向相同目录"
                    ((install_count++)) || true
                    success_dirs+=("$agent_name")
                    echo ""
                    continue
                fi
                echo "⚠ 目标已存在，正在备份到 ${TARGET_PATH}.backup..."
                rm -rf "${TARGET_PATH}.backup"
                mv "$TARGET_PATH" "${TARGET_PATH}.backup"
            fi

            echo "🔗 正在创建 skill 符号链接..."
            ln -s "$SOURCE" "$TARGET_PATH"
            echo "✓ 已链接 skill: $TARGET_PATH -> $SOURCE"

            # 记录安装
            record_install "$SKILL_NAME" "$SOURCE" "$TARGET_PATH"
            ((install_count++)) || true
            success_dirs+=("$agent_name")
            echo ""
            continue
        fi
    fi

    # ---- GitHub 来源 ----
    if [ "$SOURCE_TYPE" = "github-subdir" ] || [ "$SOURCE_TYPE" = "github" ]; then
        TARGET_PATH="$SKILLS_DIR/$GH_SKILL_NAME"
        mkdir -p "$SKILLS_DIR"

        if [ -e "$TARGET_PATH" ]; then
            echo "⚠ 目标已存在，正在备份到 ${TARGET_PATH}.backup..."
            rm -rf "${TARGET_PATH}.backup"
            mv "$TARGET_PATH" "${TARGET_PATH}.backup"
        fi

        cp -R "$TEMP_CLONE_DIR/$GH_SKILL_NAME" "$TARGET_PATH"
        echo "✓ 已安装: $TARGET_PATH"

        # 记录安装
        if command -v python3 &> /dev/null; then
            RECORD_SCRIPT="$SCRIPT_DIR/record.py"
            if [ -f "$RECORD_SCRIPT" ]; then
                local_args=()
                if [ "$SOURCE_TYPE" = "github-subdir" ]; then
                    local_args=(--remote-url "$CLONE_URL/tree/${INSTALL_BRANCH}/$SUBPATH" --remote-subpath "$SUBPATH")
                else
                    local_args=(--remote-url "$CLONE_URL")
                fi
                python3 "$RECORD_SCRIPT" install "$GH_SKILL_NAME" "$CLONE_URL" \
                    --path "$TARGET_PATH" \
                    --install-type remote \
                    --install-commit "$INSTALL_COMMIT" \
                    --install-branch "$INSTALL_BRANCH" \
                    "${local_args[@]}" 2>/dev/null || true
            fi
        fi

        ((install_count++)) || true
        success_dirs+=("$agent_name")
        echo ""
    fi

done

# ---- 清理临时目录 ----
if [ -n "$TEMP_CLONE_DIR" ] && [ -d "$TEMP_CLONE_DIR" ]; then
    rm -rf "$TEMP_CLONE_DIR"
fi

# ---- 安全检查（GitHub 来源，只检查一次）----
if [ "$SOURCE_TYPE" = "github" ] || [ "$SOURCE_TYPE" = "github-subdir" ]; then
    if [ ${#success_dirs[@]} -gt 0 ]; then
        FIRST_AGENT_DIR="${ALL_AGENT_DIRS[0]}"
        CHECK_PATH="$FIRST_AGENT_DIR/skills/$GH_SKILL_NAME"

        if command -v python3 &> /dev/null && [ -d "$CHECK_PATH" ]; then
            SECURITY_SCRIPT="$SCRIPT_DIR/security.py"
            if [ -f "$SECURITY_SCRIPT" ]; then
                echo "🔍 正在进行安全检查..."
                python3 "$SECURITY_SCRIPT" "$CHECK_PATH" 2>/dev/null || {
                    echo ""
                    echo "⚠️  安全检查发现问题，请查看上方报告"
                    echo "   如需继续使用，请自行评估风险"
                }
            fi
        else
            echo "💡 提示: 未检测到 Python，跳过安全检查"
        fi
    fi
fi

# ---- 汇总 ----
echo ""
echo "========================================"
echo "📊 安装汇总"
echo "========================================"
if [ "$install_count" -gt 0 ]; then
    echo "  成功: $install_count 个 Agent 目录"
    for d in "${success_dirs[@]}"; do
        echo "    ✅ $d"
    done
fi
if [ "$fail_count" -gt 0 ]; then
    echo "  失败: $fail_count"
fi
echo "========================================"

#!/bin/bash

# Skill & Command Manager - List Script
# 列出已安装的 skills 和 commands

ORIGINAL_PWD="$PWD"
# 获取脚本所在目录
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
MANAGER_DIR="$(dirname "$SCRIPT_DIR")"
TARGET_HELPER="$SCRIPT_DIR/target.sh"

if [ -f "$TARGET_HELPER" ]; then
    # shellcheck source=target.sh
    source "$TARGET_HELPER"
else
    echo "❌ 错误: 找不到目标目录识别模块: $TARGET_HELPER"
    exit 1
fi

SCRIPT_AGENT_DIR="$(find_agent_config_dir "$MANAGER_DIR" "$PWD/.claude")"
AGENT_DIR="$(find_agent_config_dir "$ORIGINAL_PWD" "$SCRIPT_AGENT_DIR")"
SKILLS_DIR="$AGENT_DIR/skills"
COMMANDS_DIR="$AGENT_DIR/commands"

# 列出 skills
list_skills() {
    local dir="$1"
    if [ ! -d "$dir" ]; then
        return
    fi

    echo "📋 已安装的 Skills"
    echo ""

    count=0
    for item in "$dir"/*; do
        if [ -e "$item" ] && [ "$(basename "$item")" != "skill-manager" ]; then
            name=$(basename "$item")

            if [ -L "$item" ]; then
                # 符号链接
                target=$(readlink "$item")
                echo "🔗 $name"
                echo "   类型: 符号链接"
                echo "   指向: $target"
            elif [ -d "$item" ]; then
                # 目录
                if [ -d "$item/.git" ]; then
                    # Git 仓库
                    remote=$(cd "$item" && git remote get-url origin 2>/dev/null || echo "未知")
                    branch=$(cd "$item" && git branch --show-current 2>/dev/null || echo "未知")
                    echo "📦 $name"
                    echo "   类型: Git 克隆"
                    echo "   仓库: $remote"
                    echo "   分支: $branch"
                else
                    # 普通目录
                    echo "📁 $name"
                    echo "   类型: 本地目录"
                fi
            fi
            echo ""
            ((count++))
        fi
    done

    if [ "$count" -eq 0 ]; then
        echo "暂无已安装的 skills"
    else
        echo "总计: $count 个 skills"
    fi
}

# 列出 commands
list_commands() {
    local dir="$1"
    if [ ! -d "$dir" ]; then
        return
    fi

    echo ""
    echo "📋 已安装的 Commands"
    echo ""

    count=0
    for item in "$dir"/*.md; do
        if [ -e "$item" ]; then
            name=$(basename "$item" .md)

            if [ -L "$item" ]; then
                # 符号链接
                target=$(readlink "$item")
                echo "🔗 $name"
                echo "   类型: 符号链接"
                echo "   指向: $target"
            elif [ -f "$item" ]; then
                # 普通文件
                echo "📄 $name"
                echo "   类型: 本地文件"
            fi
            echo ""
            ((count++))
        fi
    done

    if [ "$count" -eq 0 ]; then
        echo "暂无已安装的 commands"
    else
        echo "总计: $count 个 commands"
    fi
}

# 执行列表
list_skills "$SKILLS_DIR"
list_commands "$COMMANDS_DIR"

#!/usr/bin/env python3
"""
Skill Manager - Record Management Module
管理 Skill 安装记录、版本追踪和更新检查
"""

import json
import os
import sys
import re
import subprocess
import hashlib
from datetime import datetime
from pathlib import Path
from typing import Optional
from urllib.parse import urlparse

# 获取脚本所在目录
SCRIPT_DIR = Path(__file__).parent.resolve()
MANAGER_DIR = SCRIPT_DIR.parent
ASSETS_DIR = MANAGER_DIR / "assets"
REGISTRY_FILE = ASSETS_DIR / "skill-registry.json"
EXAMPLE_FILE = ASSETS_DIR / "skill-registry.example.json"

# 确保 assets 目录存在
ASSETS_DIR.mkdir(exist_ok=True)


def get_current_timestamp():
    """获取当前时间戳 (ISO 8601 格式)"""
    return datetime.now().astimezone().isoformat(timespec="seconds")


def _migrate_entry(name: str, entry: dict) -> dict:
    """为旧条目填充缺失的新字段"""
    source = entry.get("source", "")
    if "install_type" not in entry:
        if "github.com" in source or ("/" in source and not source.startswith("/") and not source.startswith("~")):
            entry["install_type"] = "remote"
        else:
            entry["install_type"] = "local"
    if "install_commit" not in entry:
        entry["install_commit"] = None
    if "install_branch" not in entry:
        entry["install_branch"] = None
    if "remote_url" not in entry:
        entry["remote_url"] = None
    if "remote_subpath" not in entry:
        entry["remote_subpath"] = None
    if "last_check_at" not in entry:
        entry["last_check_at"] = None
    return entry


def load_registry() -> dict:
    """加载 Skill 注册表（自动迁移旧条目）"""
    if REGISTRY_FILE.exists():
        try:
            with open(REGISTRY_FILE, 'r', encoding='utf-8') as f:
                data = json.load(f)
                registry = {k: _migrate_entry(k, v) for k, v in data.items() if not k.startswith('_')}
                return registry
        except (json.JSONDecodeError, IOError):
            pass

    # 如果注册表不存在，尝试从示例文件初始化
    if EXAMPLE_FILE.exists():
        try:
            with open(EXAMPLE_FILE, 'r', encoding='utf-8') as f:
                data = json.load(f)
                registry = {k: _migrate_entry(k, v) for k, v in data.items() if not k.startswith('_')}
                if registry:
                    save_registry(registry)
                    return registry
        except (json.JSONDecodeError, IOError):
            pass

    return {}


def save_registry(registry: dict):
    """保存 Skill 注册表"""
    with open(REGISTRY_FILE, 'w', encoding='utf-8') as f:
        json.dump(registry, f, indent=2, ensure_ascii=False)


def get_skill_version(skill_path: Path) -> Optional[str]:
    """从 SKILL.md 读取版本号"""
    skill_md = skill_path / "SKILL.md"
    if not skill_md.exists():
        skill_md = skill_path / "skill.md"
    
    if skill_md.exists():
        try:
            content = skill_md.read_text(encoding='utf-8')
            # 匹配 version: "1.2.0" 或 version: "1.2.0"
            match = re.search(r'version:\s*["\']?(\d+\.\d+\.\d+)["\']?', content, re.IGNORECASE)
            if match:
                return match.group(1)
        except Exception:
            pass
    return None


def get_skill_info(skill_path: Path) -> dict:
    """获取 Skill 的详细信息"""
    skill_md = skill_path / "SKILL.md"
    if not skill_md.exists():
        skill_md = skill_path / "skill.md"
    
    info = {
        "name": skill_path.name,
        "version": None,
        "description": None,
        "author": None,
        "homepage": None,
        "updated_at": None,
    }
    
    if skill_md.exists():
        try:
            content = skill_md.read_text(encoding='utf-8')
            
            # 提取 version
            match = re.search(r'version:\s*["\']?(\d+\.\d+\.\d+)["\']?', content, re.IGNORECASE)
            if match:
                info["version"] = match.group(1)
            
            # 提取 description
            match = re.search(r'description:\s*["\']([^"\']+)["\']', content, re.IGNORECASE)
            if match:
                info["description"] = match.group(1)
            
            # 提取 author
            match = re.search(r'author:\s*["\']([^"\']+)["\']', content, re.IGNORECASE)
            if match:
                info["author"] = match.group(1)
            
            # 提取 homepage
            match = re.search(r'homepage:\s*["\']([^"\']+)["\']', content, re.IGNORECASE)
            if match:
                info["homepage"] = match.group(1)
        except Exception:
            pass
    
    return info


def parse_github_url(url: str) -> Optional[tuple]:
    """解析 GitHub URL，返回 (owner, repo, subpath)

    支持格式:
    - https://github.com/owner/repo
    - https://github.com/owner/repo/tree/branch/path/to/skill
    - owner/repo
    - owner/repo/branch/path/to/skill
    """
    if not url:
        return None

    # 处理简写格式 owner/repo[/branch/path]
    if '/' in url and not url.startswith('http'):
        parts = url.split('/')
        if len(parts) >= 2:
            subpath = '/'.join(parts[2:]) if len(parts) > 2 else None
            return (parts[0], parts[1], subpath)
        return None

    # 处理完整 URL
    parsed = urlparse(url)
    if 'github.com' in parsed.netloc:
        path_parts = [p for p in parsed.path.split('/') if p]
        if len(path_parts) >= 2:
            owner = path_parts[0]
            repo = path_parts[1].replace('.git', '')
            # 处理 /tree/branch/subpath 格式
            if len(path_parts) >= 5 and path_parts[2] == 'tree':
                subpath = '/'.join(path_parts[4:])
                return (owner, repo, subpath if subpath else None)
            # 处理 /blob/branch/subpath 格式
            elif len(path_parts) >= 5 and path_parts[2] == 'blob':
                subpath = '/'.join(path_parts[4:])
                return (owner, repo, subpath if subpath else None)
            else:
                subpath = '/'.join(path_parts[2:]) if len(path_parts) > 2 else None
                return (owner, repo, subpath)

    return None


def get_raw_github_content(owner: str, repo: str, path: str = None, branch: str = "main") -> Optional[str]:
    """通过 raw.githubusercontent.com 获取 GitHub 文件内容"""
    try:
        if path:
            url = f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}/{path}"
        else:
            # 默认获取 SKILL.md
            url = f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}/SKILL.md"
        
        import urllib.request
        req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
        with urllib.request.urlopen(req, timeout=10) as resp:
            return resp.read().decode('utf-8')
    except Exception:
        return None


def get_github_changelog(owner: str, repo: str, branch: str = "main", skill_path: str = None) -> Optional[str]:
    """获取 GitHub 仓库的 CHANGELOG 内容"""
    # 构建 CHANGELOG.md 的路径
    if skill_path:
        # 如果 skill_path 是目录，需要加上 CHANGELOG.md
        if not skill_path.endswith("CHANGELOG.md"):
            skill_path = f"{skill_path}/CHANGELOG.md"
    else:
        skill_path = "CHANGELOG.md"
    
    return get_raw_github_content(owner, repo, skill_path, branch)


def get_github_commits(owner: str, repo: str, branch: str = "main", skill_path: str = None, limit: int = 5) -> list:
    """获取 GitHub 仓库/文件的最近 commits"""
    try:
        # 构建 commits URL
        if skill_path:
            url = f"https://github.com/{owner}/{repo}/commits/{branch}/{skill_path}"
        else:
            url = f"https://github.com/{owner}/{repo}/commits/{branch}"

        html = fetch_webpage(url)
        if not html:
            return []

        commits = []

        # GitHub 在 <script type="application/json" data-target="react-app.embeddedData"> 中嵌入了 JSON
        json_pattern = re.compile(
            r'<script[^>]*data-target="react-app\.embeddedData"[^>]*>\s*(\{.*?\})\s*</script>',
            re.DOTALL
        )
        match = json_pattern.search(html)
        if match:
            try:
                payload = json.loads(match.group(1))
                for group in payload.get("payload", {}).get("commitGroups", []):
                    for c in group.get("commits", []):
                        commit = {
                            "sha": c.get("oid", "")[:7],
                            "time": c.get("committedDate", ""),
                            "message": c.get("shortMessage", ""),
                            "url": f"https://github.com/{owner}/{repo}/commit/{c.get('oid', '')[:7]}"
                        }
                        if commit["sha"] and commit["sha"] not in [x["sha"] for x in commits]:
                            commits.append(commit)
                            if len(commits) >= limit:
                                return commits
            except (json.JSONDecodeError, KeyError):
                pass

        return commits
    except Exception:
        return []


def get_github_skill_version(owner: str, repo: str, branch: str = "main", skill_path: str = None) -> Optional[tuple]:
    """获取远程 Skill 的版本号和最后更新时间"""
    # 构建 SKILL.md 的路径
    if skill_path:
        # 如果 skill_path 是目录，需要加上 SKILL.md
        if not skill_path.endswith("SKILL.md"):
            skill_path = f"{skill_path}/SKILL.md"
    else:
        skill_path = "SKILL.md"
    
    content = get_raw_github_content(owner, repo, skill_path, branch)
    if not content:
        return None, None
    
    version = None
    updated = None
    
    # 匹配 version
    match = re.search(r'version:\s*["\']?(\d+\.\d+\.\d+)["\']?', content, re.IGNORECASE)
    if match:
        version = match.group(1)
    
    # 尝试从原始 URL 获取最后更新
    # 注意：raw.githubusercontent.com 不提供修改时间，我们需要通过其他方式
    # 一种方式是检查 GitHub commits API，但用户说不使用 API
    # 另一种方式是在返回内容中标注获取时间
    
    return version, get_current_timestamp()


def fetch_webpage(url: str) -> Optional[str]:
    """获取网页内容"""
    try:
        import urllib.request
        req = urllib.request.Request(url, headers={
            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36'
        })
        with urllib.request.urlopen(req, timeout=15) as resp:
            return resp.read().decode('utf-8', errors='ignore')
    except Exception:
        return None


def get_github_last_modified(owner: str, repo: str, skill_path: str = None, branch: str = "main") -> Optional[str]:
    """获取 GitHub 文件的最后修改时间（通过网页）"""
    # 构建文件的路径
    if skill_path:
        # 如果 skill_path 是目录，需要加上 SKILL.md
        if not skill_path.endswith("SKILL.md"):
            skill_path = f"{skill_path}/SKILL.md"
    else:
        skill_path = "SKILL.md"
    
    try:
        # GitHub 的 blob 页面有 relative-time 标签
        url = f"https://github.com/{owner}/{repo}/blob/{branch}/{skill_path}"
        html = fetch_webpage(url)
        
        if html:
            # 查找 <relative-time> 标签
            match = re.search(r'<relative-time[^>]*datetime="([^"]+)"', html)
            if match:
                return match.group(1)
            
            # 备用：查找 commit 信息
            match = re.search(r'data-pjax-date="([^"]+)"', html)
            if match:
                return match.group(1)
    except Exception:
        pass
    return None


def get_local_skill_info(skill_path: Path) -> dict:
    """获取本地已安装 Skill 的完整信息"""
    registry = load_registry()
    name = skill_path.name
    
    # 先从注册表获取基础信息
    base_info = registry.get(name, {})
    
    # 获取 SKILL.md 中的信息
    skill_md = skill_path / "SKILL.md"
    if not skill_md.exists():
        skill_md = skill_path / "skill.md"
    
    if skill_md.exists():
        content = skill_md.read_text(encoding='utf-8')
        
        # 提取没有的信息
        if not base_info.get("description"):
            match = re.search(r'description:\s*["\']([^"\']+)["\']', content, re.IGNORECASE)
            if match:
                base_info["description"] = match.group(1)
        
        if not base_info.get("version"):
            match = re.search(r'version:\s*["\']?(\d+\.\d+\.\d+)["\']?', content, re.IGNORECASE)
            if match:
                base_info["version"] = match.group(1)
                base_info["current_version"] = match.group(1)
        
        if not base_info.get("homepage"):
            match = re.search(r'homepage:\s*["\']([^"\']+)["\']', content, re.IGNORECASE)
            if match:
                base_info["homepage"] = match.group(1)
    else:
        base_info["current_version"] = base_info.get("version")
    
    base_info["name"] = name
    base_info["local_path"] = str(skill_path)
    
    return base_info


def record_install(skill_name: str, source: str, skill_path: Path = None, action: str = "install",
                   install_type: str = None, install_commit: str = None,
                   install_branch: str = None, remote_url: str = None,
                   remote_subpath: str = None):
    """记录 Skill 安装/更新"""
    registry = load_registry()

    # 自动推断 install_type
    if not install_type:
        if source and ("github.com" in source or ("/" in source and not source.startswith("/") and not source.startswith("~"))):
            install_type = "remote"
        else:
            install_type = "local"

    info = {
        "name": skill_name,
        "source": source,
        "install_type": install_type,
        "installed_at": get_current_timestamp(),
        "last_updated": get_current_timestamp(),
        "installed_version": None,
        "current_version": None,
        "description": None,
        "homepage": None,
        "install_commit": install_commit,
        "install_branch": install_branch,
        "remote_url": remote_url or (source if install_type == "remote" else None),
        "remote_subpath": remote_subpath,
        "last_check_at": None,
    }
    
    # 如果有本地路径，读取 SKILL.md
    if skill_path and skill_path.exists():
        skill_info = get_skill_info(skill_path)
        info["installed_version"] = skill_info.get("version")
        info["current_version"] = skill_info.get("version")
        info["description"] = skill_info.get("description")
        info["homepage"] = skill_info.get("homepage")
    
    # 解析 GitHub 来源获取远程版本
    if source:
        gh_info = parse_github_url(source)
        if gh_info:
            owner, repo, subpath = gh_info
            remote_version, _ = get_github_skill_version(owner, repo, skill_path=subpath)
            if remote_version:
                info["latest_version"] = remote_version
                if not info["current_version"]:
                    info["current_version"] = remote_version
    
    # 更新或创建记录
    registry[skill_name] = info
    save_registry(registry)
    
    return info


def record_update(skill_name: str, old_version: str = None, new_version: str = None):
    """记录 Skill 更新"""
    registry = load_registry()
    
    if skill_name in registry:
        registry[skill_name]["last_updated"] = get_current_timestamp()
        if new_version:
            registry[skill_name]["current_version"] = new_version
            registry[skill_name]["installed_version"] = old_version or registry[skill_name].get("installed_version")
        save_registry(registry)
    
    return registry.get(skill_name)


def check_updates_for_skill(skill_name: str) -> dict:
    """检查单个 Skill 的更新状态"""
    registry = load_registry()
    skill_info = registry.get(skill_name, {})

    source = skill_info.get("source")
    current_version = skill_info.get("current_version")
    installed_at = skill_info.get("installed_at")

    result = {
        "name": skill_name,
        "source": source,
        "current_version": current_version,
        "latest_version": current_version,
        "has_update": False,
        "changelog": None,
        "commits": [],
        "last_modified": None,
        "error": None,
    }

    if not source:
        result["error"] = "无来源信息"
        return result

    # 解析 GitHub 来源
    # 优先使用 remote_subpath（精确到 Skill 子目录），其次解析 remote_url
    remote_url = skill_info.get("remote_url") or source
    remote_subpath = skill_info.get("remote_subpath")

    gh_info = parse_github_url(remote_url)
    if not gh_info:
        result["error"] = "无法解析来源"
        return result

    owner, repo, url_subpath = gh_info
    # 使用精确的 subpath：remote_subpath > URL 解析 > None
    subpath = remote_subpath or url_subpath

    # 策略 1: 有版本号 → 比较版本
    remote_version, fetch_time = get_github_skill_version(owner, repo, skill_path=subpath)
    if remote_version and current_version:
        result["latest_version"] = remote_version
        result["has_update"] = remote_version != current_version

    # 策略 2: 无版本号 → 检查最近 commits 是否有新于安装时间的
    if not result["has_update"] and not current_version:
        commits = get_github_commits(owner, repo, skill_path=subpath)
        if commits and installed_at:
            try:
                installed_dt = datetime.fromisoformat(installed_at)
                for c in commits:
                    commit_time = c.get("time", "")
                    if commit_time:
                        commit_dt = datetime.fromisoformat(commit_time.replace("Z", "+00:00"))
                        # commit 时间晚于安装时间 → 有更新
                        if commit_dt > installed_dt:
                            result["has_update"] = True
                            break
            except (ValueError, TypeError):
                # 时间解析失败，有 commits 就认为可能有更新
                if commits:
                    result["has_update"] = True
        if commits:
            result["commits"] = commits

    # 补充信息：changelog 和最后修改时间
    changelog = get_github_changelog(owner, repo, skill_path=subpath)
    if changelog:
        result["changelog"] = changelog

    # 如果策略 1 没获取到 commits（有版本号时也要获取 commits 作为补充信息）
    if not result["commits"]:
        commits = get_github_commits(owner, repo, skill_path=subpath)
        if commits:
            result["commits"] = commits

    last_modified = get_github_last_modified(owner, repo, skill_path=subpath)
    if last_modified:
        result["last_modified"] = last_modified

    # 更新 last_check_at
    now = get_current_timestamp()
    reg = load_registry()
    if skill_name in reg:
        reg[skill_name]["last_check_at"] = now
        if remote_version:
            reg[skill_name]["latest_version"] = remote_version
        save_registry(reg)
    result["last_check_at"] = now

    return result


def check_all_updates() -> list:
    """检查所有已安装 Skill 的更新状态（仅远程安装的 Skill 检查远程更新）"""
    registry = load_registry()
    results = []

    for skill_name, entry in registry.items():
        install_type = entry.get("install_type", "local")
        source = entry.get("source", "")
        is_remote = install_type == "remote" or "github.com" in source

        if is_remote:
            result = check_updates_for_skill(skill_name)
            results.append(result)
        else:
            # 本地 Skill（符号链接）自动同步，无需远程检查
            results.append({
                "name": skill_name,
                "source": source,
                "current_version": entry.get("current_version"),
                "latest_version": entry.get("current_version"),
                "has_update": False,
                "changelog": None,
                "commits": [],
                "last_modified": None,
                "error": None,
                "skipped": True,
            })

    return results


DEFAULT_STALE_THRESHOLD_DAYS = 7


def check_stale_remote_skills(threshold_days: int = DEFAULT_STALE_THRESHOLD_DAYS) -> list:
    """检查超过阈值的远程 Skill 更新状态"""
    registry = load_registry()
    results = []
    now = datetime.now().astimezone()

    for skill_name, entry in registry.items():
        source = entry.get("source", "")
        install_type = entry.get("install_type", "local")
        is_remote = install_type == "remote" or "github.com" in source
        if not is_remote:
            continue

        last_check = entry.get("last_check_at")
        if last_check:
            try:
                last_check_dt = datetime.fromisoformat(last_check)
                days_since = (now - last_check_dt).days
                if days_since < threshold_days:
                    continue
            except (ValueError, TypeError):
                pass

        result = check_updates_for_skill(skill_name)
        results.append(result)

    return results


def summarize_updates(result: dict) -> str:
    """将更新检测结果总结为一段简明的更新摘要"""
    commits = result.get("commits", [])
    changelog = result.get("changelog")
    current = result.get("current_version")
    latest = result.get("latest_version")

    parts = []

    # 版本变化
    if current and latest and current != latest:
        parts.append(f"版本 {current} → {latest}")

    # 从 changelog 提取最新版本的更新说明
    changelog_extracted = False
    if changelog:
        sections = re.split(r'^##\s', changelog, maxsplit=2)
        if len(sections) > 1:
            latest_section = sections[1]
            summary_lines = []
            for line in latest_section.split('\n'):
                line = line.strip().lstrip('- ').strip()
                if line and not line.startswith('#') and not line.startswith('['):
                    summary_lines.append(line)
                    if len(summary_lines) >= 3:
                        break
            if summary_lines:
                parts.append('；'.join(summary_lines))
                changelog_extracted = True

    # 从 commits 生成摘要（仅在 changelog 未提取到内容时）
    if commits and not changelog_extracted:
        summaries = []
        for c in commits[:5]:
            msg = c.get("message", "")
            if not msg:
                continue
            if msg.startswith("Merge pull request"):
                continue
            msg = msg.split('\n')[0]
            msg = re.sub(r'^(feat|fix|docs|chore|refactor|perf|test|ci|build|style)(\([^)]*\))?:\s*', '', msg)
            if msg:
                summaries.append(msg[:50])
        if summaries:
            parts.append('；'.join(summaries))

    # 兜底：只说有多少新 commit
    if not parts and commits:
        parts.append(f"安装后有 {len(commits)} 个新提交")

    return '，'.join(parts) if parts else "检测到远程更新"


def format_recommendation_report(results: list) -> str:
    """格式化更新推荐报告（仅对有更新的 skill 输出）"""
    has_update = [r for r in results if r.get("has_update")]
    if not has_update:
        return ""

    lines = []
    lines.append("=" * 60)
    lines.append("Skill 更新推荐")
    lines.append("=" * 60)
    lines.append("")

    for r in has_update:
        lines.append(f"  * {r['name']}")
        # 更新摘要
        summary = summarize_updates(r)
        lines.append(f"    {summary}")
        if r.get("source"):
            lines.append(f"    更新: skill-manager install {r['source']}")
        lines.append("")

    lines.append("=" * 60)
    return "\n".join(lines)


def format_version_list(updates: list) -> str:
    """格式化版本列表为可读文本"""
    if not updates:
        return "没有已安装的 Skills\n"
    
    lines = []
    lines.append("=" * 60)
    lines.append("🔍 Skill 更新检查")
    lines.append("=" * 60)
    lines.append("")
    
    # 按状态分组
    has_update = [u for u in updates if u.get("has_update")]
    up_to_date = [u for u in updates if not u.get("has_update") and not u.get("error") and not u.get("skipped")]
    local_skills = [u for u in updates if u.get("skipped")]
    errors = [u for u in updates if u.get("error")]
    
    if has_update:
        lines.append("📦 有可用更新:")
        lines.append("-" * 40)
        for u in has_update:
            lines.append(f"  • {u['name']}")
            summary = summarize_updates(u)
            lines.append(f"    {summary}")
            lines.append("")
    
    if up_to_date:
        lines.append("✅ 已是最新:")
        lines.append("-" * 40)
        for u in up_to_date:
            lines.append(f"  • {u['name']} (v{u.get('current_version', '?')})")
        lines.append("")
    
    if errors:
        lines.append("⚠️  检查失败:")
        lines.append("-" * 40)
        for u in errors:
            lines.append(f"  • {u['name']}: {u.get('error')}")
        lines.append("")

    if local_skills:
        lines.append("🔗 本地安装（自动同步，无需检查）:")
        lines.append("-" * 40)
        for u in local_skills:
            ver = u.get('current_version', '?')
            lines.append(f"  • {u['name']}" + (f" (v{ver})" if ver else ""))
        lines.append("")

    lines.append("=" * 60)
    
    return "\n".join(lines)


def format_install_record(info: dict) -> str:
    """格式化安装记录"""
    lines = []
    lines.append("=" * 40)
    lines.append("📦 Skill 安装记录")
    lines.append("=" * 40)
    lines.append(f"  名称: {info.get('name', '未知')}")
    lines.append(f"  来源: {info.get('source', '未知')}")
    lines.append(f"  版本: {info.get('current_version', '未知')}")
    lines.append(f"  时间: {info.get('installed_at', '未知')}")
    if info.get("description"):
        lines.append(f"  描述: {info['description']}")
    lines.append("=" * 40)
    return "\n".join(lines)


def main():
    """主入口"""
    if len(sys.argv) < 2:
        print("Usage:")
        print("  record.py install <skill_name> <source> [--path <path>] [--install-type <type>] [--install-commit <hash>] [--install-branch <branch>] [--remote-url <url>]")
        print("  record.py check <skill_name>")
        print("  record.py check-all")
        print("  record.py auto-check [--threshold <days>]")
        print("  record.py list")
        print("  record.py update <skill_name> [--from <version>] [--to <version>]")
        sys.exit(1)
    
    command = sys.argv[1]
    
    if command == "install":
        # record.py install <skill_name> <source> [--path <path>] [--install-type <type>] [--install-commit <hash>] [--install-branch <branch>] [--remote-url <url>] [--remote-subpath <path>]
        skill_name = sys.argv[2] if len(sys.argv) > 2 else None
        source = sys.argv[3] if len(sys.argv) > 3 else None
        path = None
        install_type = None
        install_commit = None
        install_branch = None
        remote_url = None
        remote_subpath = None

        for i, arg in enumerate(sys.argv):
            if arg == "--path" and len(sys.argv) > i + 1:
                path = Path(sys.argv[i + 1])
            elif arg == "--install-type" and len(sys.argv) > i + 1:
                install_type = sys.argv[i + 1]
            elif arg == "--install-commit" and len(sys.argv) > i + 1:
                install_commit = sys.argv[i + 1]
            elif arg == "--install-branch" and len(sys.argv) > i + 1:
                install_branch = sys.argv[i + 1]
            elif arg == "--remote-url" and len(sys.argv) > i + 1:
                remote_url = sys.argv[i + 1]
            elif arg == "--remote-subpath" and len(sys.argv) > i + 1:
                remote_subpath = sys.argv[i + 1]

        if not skill_name or not source:
            print("❌ 错误: 请提供 skill_name 和 source")
            sys.exit(1)

        info = record_install(skill_name, source, path,
                              install_type=install_type,
                              install_commit=install_commit,
                              install_branch=install_branch,
                              remote_url=remote_url,
                              remote_subpath=remote_subpath)
        print(format_install_record(info))
    
    elif command == "auto-check":
        threshold = DEFAULT_STALE_THRESHOLD_DAYS
        for i, arg in enumerate(sys.argv):
            if arg == "--threshold" and len(sys.argv) > i + 1:
                threshold = int(sys.argv[i + 1])
        results = check_stale_remote_skills(threshold_days=threshold)
        report = format_recommendation_report(results)
        if report:
            print(report)

    elif command == "check":
        # record.py check <skill_name>
        skill_name = sys.argv[2] if len(sys.argv) > 2 else None
        if not skill_name:
            print("❌ 错误: 请提供 skill_name")
            sys.exit(1)
        
        result = check_updates_for_skill(skill_name)
        print(json.dumps(result, indent=2, ensure_ascii=False))
    
    elif command == "check-all":
        results = check_all_updates()
        print(format_version_list(results))
    
    elif command == "list":
        registry = load_registry()
        if not registry:
            print("📭 暂无安装记录")
        else:
            for name, info in registry.items():
                print(f"\n📦 {name}")
                print(f"   版本: {info.get('current_version', '未知')}")
                print(f"   来源: {info.get('source', '未知')}")
                print(f"   类型: {info.get('install_type', '未知')}")
                print(f"   安装时间: {info.get('installed_at', '未知')}")
                if info.get("install_commit"):
                    print(f"   安装 Commit: {info['install_commit']}")
                if info.get("install_branch"):
                    print(f"   安装 Branch: {info['install_branch']}")
                if info.get("last_check_at"):
                    print(f"   上次检查: {info['last_check_at']}")
                if info.get("description"):
                    print(f"   描述: {info['description']}")
    
    elif command == "update":
        # record.py update <skill_name> [--from <version>] [--to <version>]
        skill_name = sys.argv[2] if len(sys.argv) > 2 else None
        old_version = None
        new_version = None
        
        for i, arg in enumerate(sys.argv):
            if arg == "--from" and len(sys.argv) > i + 1:
                old_version = sys.argv[i + 1]
            if arg == "--to" and len(sys.argv) > i + 1:
                new_version = sys.argv[i + 1]
        
        if not skill_name:
            print("❌ 错误: 请提供 skill_name")
            sys.exit(1)
        
        info = record_update(skill_name, old_version, new_version)
        if info:
            print(f"✅ 已更新记录: {skill_name}")
            if old_version and new_version:
                print(f"   {old_version} → {new_version}")
        else:
            print(f"⚠️ 未找到记录: {skill_name}")
    
    else:
        print(f"❌ 未知命令: {command}")
        sys.exit(1)


if __name__ == "__main__":
    main()