level-up-mcp-server-cn 0.4.0

package/dist/tools/growth-plan.js

@@ -0,0 +1,791 @@
+// ============================================================
+// tools/growth-plan.ts — Growth Plan (Tool 70)
+// ============================================================
+// Generates a prioritised action list for an agent to reach
+// a target rank, skill proficiency, or next level.
+//
+// Reads the agent's current state against requirements and
+// produces concrete steps ordered by XP efficiency.
+// Results are cached in growth_plan_cache.
+// ============================================================
+import { z } from "zod";
+import { supabase } from "../services/supabase.js";
+import { ok, fail, handleSupabaseError } from "../services/errors.js";
+import { toMcpResponse, logRegistered } from "../services/register.js";
+import { uuidSchema } from "../schemas/common.js";
+import * as crypto from "crypto";
+// Handler registry — populated by registerGrowthPlanTools(), accessed by dispatchers
+export const growthPlanHandlers = {};
+// ---- Helpers ----
+function hashTarget(target) {
+    const sorted = JSON.stringify(target, Object.keys(target).sort());
+    return crypto.createHash("sha256").update(sorted).digest("hex").slice(0, 16);
+}
+export function registerGrowthPlanTools(server) {
+    console.error("\n📋 Section 14: Growth Plan");
+    // ================================================================
+    // Tool 70: levelup_get_growth_plan
+    // ================================================================
+    server.registerTool("levelup_get_growth_plan", {
+        title: "获取成长计划",
+        description: `生成一个优先排序的行动列表，用于达到目标段位、技能等级或下一等级。
+
+当用户询问如何升级、应该做什么、或如何达到某个段位时调用。
+返回有序步骤：安装工具、完成任务、获取技能——每步附带
+经验值估算和冷却时间说明。按顺序执行步骤。
+
+参数:
+  - agent_id (uuid): 目标智能体。
+  - target (object): 以下之一：
+      - { type: "next_level" } — 达到下一等级
+      - { type: "next_rank" } — 达到下一段位
+      - { type: "rank", rank: "D" } — 达到指定段位
+      - { type: "skill_proficiency", skill_id: uuid, target_proficiency: 5 } — 达到技能等级
+  - horizon_days (integer, 可选): 规划周期（默认7天）。
+  - include_xp_estimates (boolean, 可选): 默认 true。
+
+返回:
+  当前状态、经验值差距、有序步骤、受阻步骤、警告。`,
+        inputSchema: {
+            agent_id: uuidSchema.describe("目标智能体"),
+            target: z.object({
+                type: z.enum(["next_level", "next_rank", "rank", "skill_proficiency"]).describe("目标类型"),
+                rank: z.string().optional().describe("目标段位字母（如 'D'、'C'）"),
+                skill_id: uuidSchema.optional().describe("用于 skill_proficiency 目标"),
+                target_proficiency: z.number().int().min(1).max(10).optional().describe("目标熟练度等级"),
+            }).describe("目标方向"),
+            horizon_days: z.number().int().min(1).max(30).default(7).describe("规划周期（天）"),
+            include_xp_estimates: z.boolean().default(true).describe("每步包含经验值估算"),
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, (growthPlanHandlers.gp = async (params) => {
+        // --- Check cache first ---
+        const targetHash = hashTarget(params.target);
+        const { data: cached } = await supabase
+            .from("growth_plan_cache")
+            .select("plan, generated_at, expires_at")
+            .eq("agent_id", params.agent_id)
+            .eq("target_hash", targetHash)
+            .eq("invalidated", false)
+            .gt("expires_at", new Date().toISOString())
+            .order("generated_at", { ascending: false })
+            .limit(1)
+            .maybeSingle();
+        if (cached) {
+            return toMcpResponse(ok({
+                ...cached.plan,
+                from_cache: true,
+                cached_at: cached.generated_at,
+                expires_at: cached.expires_at,
+            }));
+        }
+        // --- Fetch agent state ---
+        const { data: agent, error: agentError } = await supabase
+            .from("agents").select("id, name, level, xp, integrity_score, owner_user_id")
+            .eq("id", params.agent_id).single();
+        if (agentError)
+            return toMcpResponse(handleSupabaseError(agentError, "get_growth_plan"));
+        // Get agent's current skills
+        const { data: agentSkills } = await supabase
+            .from("agent_skills")
+            .select("skill_id, proficiency_level, usage_count")
+            .eq("agent_id", params.agent_id);
+        const skillMap = new Map((agentSkills || []).map((s) => [s.skill_id, s]));
+        // Get installed tools
+        const { data: installations } = await supabase
+            .from("agent_tool_installations")
+            .select("tool_name, tool_type")
+            .eq("agent_id", params.agent_id);
+        const installedTools = new Set((installations || []).map((i) => i.tool_name));
+        // Get current rank
+        const { data: currentRank } = await supabase
+            .from("rank_definitions")
+            .select("rank_letter, rank_name, min_level, max_level")
+            .eq("entity_type", "agent")
+            .lte("min_level", agent.level)
+            .gte("max_level", agent.level)
+            .maybeSingle();
+        // --- Determine target ---
+        let targetLevel;
+        let targetDescription;
+        let targetXp;
+        if (params.target.type === "next_level") {
+            targetLevel = agent.level + 1;
+            targetDescription = `等级 ${targetLevel}`;
+        }
+        else if (params.target.type === "next_rank" || params.target.type === "rank") {
+            // Get rank definitions
+            const { data: ranks } = await supabase
+                .from("rank_definitions")
+                .select("rank_letter, rank_name, min_level, max_level")
+                .eq("entity_type", "agent")
+                .order("min_level", { ascending: true });
+            if (params.target.type === "rank" && params.target.rank) {
+                const targetRank = (ranks || []).find((r) => r.rank_letter === params.target.rank);
+                if (!targetRank)
+                    return toMcpResponse(fail(`未找到段位 "${params.target.rank}"`));
+                targetLevel = targetRank.min_level;
+                targetDescription = `段位 ${targetRank.rank_letter} — ${targetRank.rank_name}`;
+            }
+            else {
+                // next_rank: find rank after current
+                const currentIdx = (ranks || []).findIndex((r) => r.rank_letter === currentRank?.rank_letter);
+                const nextRank = (ranks || [])[currentIdx + 1];
+                if (!nextRank)
+                    return toMcpResponse(fail("已达最高段位"));
+                targetLevel = nextRank.min_level;
+                targetDescription = `段位 ${nextRank.rank_letter} — ${nextRank.rank_name}`;
+            }
+        }
+        else {
+            // skill_proficiency — different flow
+            targetLevel = agent.level; // no level target for skill goals
+            targetDescription = `技能熟练度 ${params.target.target_proficiency || 5}`;
+        }
+        // Get XP needed from level curve
+        const { data: levelCurve } = await supabase
+            .from("level_curves")
+            .select("level, cumulative_xp")
+            .eq("entity_type", "agent")
+            .lte("level", targetLevel)
+            .order("level", { ascending: true });
+        const targetCurveEntry = (levelCurve || []).find((c) => c.level === targetLevel);
+        targetXp = targetCurveEntry?.cumulative_xp || 0;
+        const xpGap = Math.max(0, targetXp - agent.xp);
+        // --- Compute skill discount ---
+        let skillDiscountPct = 0;
+        const { data: levelReq } = await supabase
+            .from("level_requirements").select("id")
+            .eq("level", agent.level + 1).maybeSingle();
+        if (levelReq) {
+            const { data: skillDiscounts } = await supabase
+                .from("level_req_skills")
+                .select("skill_id, min_proficiency, xp_discount_pct")
+                .eq("level_requirement_id", levelReq.id);
+            for (const sd of skillDiscounts || []) {
+                const agentSkill = skillMap.get(sd.skill_id);
+                if (agentSkill && agentSkill.proficiency_level >= sd.min_proficiency) {
+                    skillDiscountPct += sd.xp_discount_pct;
+                }
+            }
+        }
+        // --- Build steps ---
+        const steps = [];
+        const blockedSteps = [];
+        const alreadyCompleted = [];
+        let stepNumber = 0;
+        // Step type 1: Tool installations that grant skill proficiency
+        const { data: toolMappings } = await supabase
+            .from("skill_tool_mappings")
+            .select("skill_id, tool_name, setup_credit");
+        // Get skill names for display
+        const allSkillIds = [...new Set([
+                ...(agentSkills || []).map((s) => s.skill_id),
+                ...(toolMappings || []).map((m) => m.skill_id),
+            ])];
+        const { data: skillDetails } = allSkillIds.length > 0
+            ? await supabase.from("skills").select("id, name, category_id").in("id", allSkillIds)
+            : { data: [] };
+        const skillNameMap = new Map((skillDetails || []).map((s) => [s.id, s.name]));
+        // Deduplicate: group skills per MCP tool
+        const mcpSkillGroups = new Map();
+        for (const mapping of toolMappings || []) {
+            const skillName = skillNameMap.get(mapping.skill_id) || mapping.tool_name;
+            const existing = mcpSkillGroups.get(mapping.tool_name) || { skills: [], totalCredit: 0 };
+            existing.skills.push(skillName);
+            existing.totalCredit += mapping.setup_credit || 1;
+            mcpSkillGroups.set(mapping.tool_name, existing);
+        }
+        const installSteps = [];
+        for (const [toolName, group] of mcpSkillGroups) {
+            if (installedTools.has(toolName)) {
+                alreadyCompleted.push({
+                    description: `已安装工具: ${toolName} (${group.skills.join(", ")})`,
+                    xp_earned: 20,
+                });
+                continue;
+            }
+            // Check if any of this tool's skills are at proficiency 0
+            const hasFoundationSkill = group.skills.some((name) => {
+                const skill = (skillDetails || []).find((s) => s.name === name);
+                return skill && !skillMap.has(skill.id);
+            });
+            const priority = hasFoundationSkill ? "high" : "medium";
+            installSteps.push({
+                step_number: 0, // renumbered later
+                priority,
+                action_type: "install_tool",
+                title: `安装 ${toolName}`,
+                description: `解锁 ${group.skills.join(" + ")}（${group.skills.length} 项技能）。奖励 20 经验值。`,
+                skills_affected: group.skills,
+                xp_estimate: 20,
+                cooldown_note: "每天最多 3 次工具安装可获得经验值。",
+                evidence_required: "api_response 或截图",
+                mcp_name: toolName,
+            });
+        }
+        // Cap install suggestions at 5 (spread across days)
+        installSteps.sort((a, b) => (a.priority === "high" ? 0 : 1) - (b.priority === "high" ? 0 : 1));
+        const cappedInstalls = installSteps.slice(0, 5);
+        // Step type 2: Task completions for XP
+        const { data: taskTypes } = await supabase
+            .from("task_types")
+            .select("id, name, base_xp, xp_tier, category")
+            .eq("status", "active")
+            .order("base_xp", { ascending: false });
+        // Get cooldown config for notes
+        const { data: cooldownConfig } = await supabase
+            .from("xp_config").select("config_value")
+            .eq("config_key", "task_cooldown_base_minutes").maybeSingle();
+        const cooldowns = (cooldownConfig?.config_value || {});
+        // Check what task types the agent has already completed
+        const { data: completedTasks } = await supabase
+            .from("tasks")
+            .select("task_type_id")
+            .eq("agent_id", params.agent_id)
+            .eq("status", "completed");
+        const completedTypeIds = new Set((completedTasks || []).map((t) => t.task_type_id));
+        const completedTypeCounts = new Map();
+        for (const t of completedTasks || []) {
+            completedTypeCounts.set(t.task_type_id, (completedTypeCounts.get(t.task_type_id) || 0) + 1);
+        }
+        // Level-gated tier access: new agents should start small and build up
+        const TIER_LEVEL_GATES = {
+            micro: 1, // Available from level 1
+            light: 1, // Available from level 1
+            standard: 1, // Available from level 1
+            complex: 5, // Unlocks at level 5 (Rank E, 5 stars)
+            major: 10, // Unlocks at level 10 (Rank D)
+        };
+        // Sort task types by XP efficiency and diversity
+        for (const tt of taskTypes || []) {
+            const cooldownMinutes = cooldowns[tt.xp_tier] || 0;
+            const xpEstimate = tt.base_xp;
+            const alreadyDone = completedTypeCounts.get(tt.id) || 0;
+            // Gate large tasks behind level requirements
+            const requiredLevel = TIER_LEVEL_GATES[tt.xp_tier] || 1;
+            if (agent.level < requiredLevel) {
+                blockedSteps.push({
+                    title: `${tt.name} (${tt.xp_tier} tier)`,
+                    blocked_reason: `需要等级 ${requiredLevel}+（当前等级 ${agent.level}）`,
+                    unblock_action: `先完成${tt.xp_tier === "major" ? "complex" : "standard"}级任务以达到等级 ${requiredLevel}。`,
+                });
+                continue;
+            }
+            // Prioritize by agent level:
+            // Low-level agents: tool installs and micro/light/standard tasks first
+            // Higher-level agents: complex/major tasks get higher priority
+            let priority;
+            if (alreadyDone === 0) {
+                // Never-done types get diversity bonus, but tier-appropriate
+                if (tt.xp_tier === "micro" || tt.xp_tier === "light") {
+                    priority = agent.level <= 3 ? "high" : "low";
+                }
+                else if (tt.xp_tier === "standard") {
+                    priority = "high";
+                }
+                else {
+                    priority = agent.level >= requiredLevel ? "medium" : "low";
+                }
+            }
+            else {
+                priority = xpEstimate >= 25 ? "medium" : "low";
+            }
+            // Calculate repetitions needed based on XP gap
+            const effectiveXpPerTask = Math.round(xpEstimate * 0.8); // assume ~80% quality multiplier
+            const repsNeeded = xpGap > 0 ? Math.min(10, Math.ceil(xpGap / Math.max(1, effectiveXpPerTask * 3))) : 1;
+            let cooldownNote = null;
+            if (cooldownMinutes > 0) {
+                cooldownNote = `${tt.xp_tier} 级别：任务间冷却 ${cooldownMinutes} 分钟。`;
+            }
+            stepNumber++;
+            steps.push({
+                step_number: stepNumber,
+                priority,
+                action_type: "complete_task",
+                title: alreadyDone === 0
+                    ? `完成一个 ${tt.name} 任务（新类型——多样性加成）`
+                    : `完成 ${repsNeeded} 个 ${tt.name} 任务`,
+                description: `${tt.category || "综合"}类任务。基础经验值：${xpEstimate}。${alreadyDone === 0 ? "首次完成此类型——有助于多样性加成。" : `已完成 ${alreadyDone} 次。`}`,
+                skills_affected: [],
+                xp_estimate: effectiveXpPerTask * repsNeeded,
+                cooldown_note: cooldownNote,
+                evidence_required: "deliverable_url 或 platform_reference",
+                task_type: tt.name,
+                task_type_id: tt.id,
+                repetitions_needed: repsNeeded,
+                repetitions_completed: Math.min(alreadyDone, repsNeeded),
+            });
+        }
+        // --- Interleave installs and tasks (max 3 installs then a task) ---
+        // Sort task steps by priority then XP
+        const priorityOrder = { high: 0, medium: 1, low: 2 };
+        steps.sort((a, b) => {
+            const pDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+            if (pDiff !== 0)
+                return pDiff;
+            return b.xp_estimate - a.xp_estimate;
+        });
+        // Interleave: for new agents, start with installs but mix in tasks
+        const interleaved = [];
+        let installIdx = 0;
+        let taskIdx = 0;
+        const taskSteps = steps; // all steps are tasks at this point
+        let installStreak = 0;
+        if (agent.level <= 3 && cappedInstalls.length > 0) {
+            // New agents: max 3 installs, then a task, repeat
+            while (installIdx < cappedInstalls.length || taskIdx < taskSteps.length) {
+                if (installIdx < cappedInstalls.length && installStreak < 3) {
+                    interleaved.push(cappedInstalls[installIdx++]);
+                    installStreak++;
+                }
+                else if (taskIdx < taskSteps.length) {
+                    interleaved.push(taskSteps[taskIdx++]);
+                    installStreak = 0;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        else {
+            // Experienced agents: tasks first, installs mixed in
+            interleaved.push(...taskSteps);
+            interleaved.push(...cappedInstalls);
+        }
+        // Re-number and differentiate priorities
+        interleaved.forEach((s, i) => {
+            s.step_number = i + 1;
+            if (i < 3)
+                s.priority = "high";
+            else if (i < 6)
+                s.priority = "medium";
+            else
+                s.priority = "low";
+        });
+        // --- Timegate warnings ---
+        const warnings = [];
+        const { data: starCooldown } = await supabase
+            .from("xp_config").select("config_value")
+            .eq("config_key", "agent_star_cooldown_hours").maybeSingle();
+        if (starCooldown?.config_value && currentRank) {
+            const cooldownHours = starCooldown.config_value[currentRank.rank_letter];
+            if (cooldownHours && cooldownHours > 0) {
+                warnings.push(`时间门控：段位 ${currentRank.rank_letter} 每颗星之间有 ${cooldownHours} 小时冷却。`);
+            }
+        }
+        if (xpGap <= 0) {
+            warnings.push("你已拥有足够的经验值达成目标。调用 levelup_check_level_up 来执行升级。");
+        }
+        // --- Recommended skillsets from ability categories ---
+        // Find which categories the agent is weakest in and recommend MCPs + skills
+        const { data: allCategories } = await supabase
+            .from("skill_categories").select("id, name, description");
+        const recommendations = [];
+        if (allCategories && agentSkills) {
+            // Group agent skills by category
+            const catProficiency = new Map();
+            for (const as of agentSkills) {
+                const skill = (skillDetails || []).find((s) => s.id === as.skill_id);
+                if (skill) {
+                    const profs = catProficiency.get(skill.category_id) || [];
+                    profs.push(as.proficiency_level);
+                    catProficiency.set(skill.category_id, profs);
+                }
+            }
+            // Recommended MCPs per category (top picks from verified sources)
+            const categoryMcps = {
+                "Software Engineering": ["Filesystem MCP", "Git MCP", "GitHub MCP"],
+                "Web Development": ["Playwright MCP", "Fetch MCP", "Firecrawl MCP"],
+                "Data Analysis": ["Memory MCP", "Brave Search MCP", "Chroma MCP"],
+                "DevOps & Infrastructure": ["GitHub MCP", "Terraform MCP", "AWS MCP", "Docker MCP"],
+                "Security & Testing": ["Snyk Agent Scan", "Playwright MCP"],
+                "Design & Visual": ["Playwright MCP"],
+                "Research & Knowledge": ["Brave Search MCP", "Fetch MCP", "arXiv MCP", "Memory MCP"],
+                "Writing & Content": ["Notion MCP", "ElevenLabs MCP"],
+                "Communication": ["Notion MCP", "Atlassian MCP"],
+                "Project Management": ["GitHub MCP", "Notion MCP", "Atlassian MCP"],
+                "Database & Backend": ["MongoDB MCP", "Chroma MCP"],
+                "Cloud & Platform": ["AWS MCP", "Cloudflare MCP", "Terraform MCP"],
+                "AI & Machine Learning": ["Sequential Thinking MCP", "Memory MCP", "Chroma MCP"],
+            };
+            const categorySkills = {
+                "Software Engineering": ["refactor", "conventional-commit", "architecture-blueprint-generator"],
+                "Web Development": ["frontend-design", "webapp-testing", "playwright-generate-test"],
+                "Data Analysis": ["xlsx", "sql-optimization", "sql-code-review"],
+                "DevOps & Infrastructure": ["devops-rollout-plan", "multi-stage-dockerfile", "cloud-design-patterns"],
+                "Security & Testing": ["agent-governance", "ai-prompt-engineering-safety-review"],
+                "Design & Visual": ["canvas-design", "brand-guidelines", "excalidraw-diagram-generator"],
+                "Research & Knowledge": ["remember", "create-technical-spike", "context-map"],
+                "Writing & Content": ["documentation-writer", "create-readme", "create-specification"],
+                "Project Management": ["breakdown-epic-pm", "prd", "create-architectural-decision-record"],
+                "AI & Machine Learning": ["claude-api", "mcp-builder", "prompt-builder", "agentic-eval"],
+            };
+            // Find weakest categories (avg proficiency < 3 or no skills)
+            for (const cat of allCategories) {
+                const profs = catProficiency.get(cat.id) || [];
+                const avgProf = profs.length > 0 ? profs.reduce((a, b) => a + b, 0) / profs.length : 0;
+                if (avgProf < 3 && recommendations.length < 5) {
+                    recommendations.push({
+                        ability: cat.name,
+                        current_proficiency: Math.round(avgProf * 10) / 10,
+                        suggested_mcps: categoryMcps[cat.name] || [],
+                        suggested_skills: categorySkills[cat.name] || [],
+                        tip: avgProf === 0
+                            ? `先安装 ${cat.name} 推荐的 MCP 来获取工具安装经验值。`
+                            : `完成更多 ${cat.name} 任务来提升熟练度。当前平均：${avgProf.toFixed(1)}/10。`,
+                    });
+                }
+            }
+        }
+        // --- Build response ---
+        const effectiveXpGap = Math.round(xpGap * (1 - skillDiscountPct / 100));
+        const plan = {
+            agent_id: agent.id,
+            agent_name: agent.name,
+            current_level: agent.level,
+            current_rank: currentRank ? `${currentRank.rank_letter} — ${currentRank.rank_name}` : "未定段",
+            current_xp: agent.xp,
+            target_description: targetDescription,
+            xp_to_target: xpGap,
+            skill_discount_pct: skillDiscountPct,
+            effective_xp_to_target: effectiveXpGap,
+            steps: interleaved.slice(0, 20), // Cap at 20 steps
+            recommended_skillsets: recommendations.length > 0 ? recommendations : undefined,
+            blocked_steps: blockedSteps,
+            already_completed: alreadyCompleted,
+            warnings,
+            generated_at: new Date().toISOString(),
+            expires_at: new Date(Date.now() + params.horizon_days * 86400_000).toISOString(),
+        };
+        // --- Cache the plan ---
+        await supabase.from("growth_plan_cache").insert({
+            agent_id: params.agent_id,
+            target_hash: targetHash,
+            plan,
+            expires_at: plan.expires_at,
+        });
+        return toMcpResponse(ok({ ...plan, from_cache: false }));
+    }));
+    logRegistered("levelup_get_growth_plan");
+    // ================================================================
+    // Tool 71: levelup_browse_skillsets
+    // ================================================================
+    // Recommended MCPs per ability (only official/org-owned repos)
+    const SKILLSET_DATA = {
+        "Software Engineering": {
+            description: "代码编写、调试、重构、架构设计",
+            mcps: [
+                { name: "Filesystem MCP", purpose: "读写和编辑项目文件", repo: "modelcontextprotocol/servers/src/filesystem", trust: "Reference", best_practice: "仅限项目目录——绝不允许访问根目录或用户主目录" },
+                { name: "Git MCP", purpose: "分支、提交、差异比较、合并", repo: "modelcontextprotocol/servers/src/git", trust: "Reference", best_practice: "提交前务必检查差异；避免强制推送" },
+                { name: "GitHub MCP", purpose: "PR、Issue、代码审查、CI", repo: "github/github-mcp-server", trust: "Official (28K stars)", best_practice: "使用最小权限的细粒度 PAT；绝不提交 token" },
+                { name: "Sequential Thinking", purpose: "架构设计的多步推理", repo: "modelcontextprotocol/servers/src/sequentialthinking", trust: "Reference", best_practice: "用于复杂的多步问题，而非简单查询" },
+            ],
+            skills: [
+                { name: "refactor", what_it_teaches: "安全重构模式、方法提取、降低复杂度", source: "GitHub", best_practice: "逐步应用；每步后运行测试" },
+                { name: "conventional-commit", what_it_teaches: "结构化提交信息（feat/fix/chore）", source: "GitHub", best_practice: "遵循项目现有的提交约定" },
+                { name: "architecture-blueprint-generator", what_it_teaches: "从代码库生成架构文档", source: "GitHub", best_practice: "架构变更时同步更新蓝图" },
+                { name: "mcp-builder", what_it_teaches: "从零开始构建 MCP 服务器", source: "Anthropic", best_practice: "遵循 MCP 规范；使用 MCP inspector 测试" },
+            ],
+            progression: "Filesystem + Git → GitHub → Sequential Thinking",
+            notes: null,
+        },
+        "Web Development": {
+            description: "前端/后端、HTML/CSS/JS、框架、API",
+            mcps: [
+                { name: "Filesystem MCP", purpose: "项目文件管理", repo: "modelcontextprotocol/servers/src/filesystem", trust: "Reference", best_practice: "仅限项目目录" },
+                { name: "Playwright MCP", purpose: "浏览器自动化、端到端测试", repo: "microsoft/playwright-mcp", trust: "Official (29K stars)", best_practice: "优先使用无障碍快照而非截图以提高速度" },
+                { name: "Fetch MCP", purpose: "HTTP 请求、API 测试", repo: "modelcontextprotocol/servers/src/fetch", trust: "Reference", best_practice: "设置合理的超时时间；不要请求不可信的 URL" },
+                { name: "Firecrawl MCP", purpose: "深度网站爬取和抓取", repo: "firecrawl/firecrawl-mcp-server", trust: "Official (5.8K stars)", best_practice: "遵守 robots.txt；仅用于自有或已授权的网站" },
+            ],
+            skills: [
+                { name: "frontend-design", what_it_teaches: "前端 UI 设计模式", source: "Anthropic", best_practice: "匹配设计系统；测试响应式断点" },
+                { name: "webapp-testing", what_it_teaches: "Web 应用测试策略", source: "Anthropic", best_practice: "测试用户流程，而非实现细节" },
+                { name: "playwright-generate-test", what_it_teaches: "生成 Playwright 端到端测试", source: "GitHub", best_practice: "使用 data-testid 选择器；避免脆弱的 CSS 选择器" },
+            ],
+            progression: "Filesystem + Fetch → Playwright → Firecrawl",
+            notes: null,
+        },
+        "Data Analysis": {
+            description: "SQL、数据处理、统计分析、可视化",
+            mcps: [
+                { name: "Filesystem MCP", purpose: "读写 CSV、JSON 等数据文件", repo: "modelcontextprotocol/servers/src/filesystem", trust: "Reference", best_practice: "写入前验证数据；转换前做好备份" },
+                { name: "Memory MCP", purpose: "跨会话跟踪分析上下文", repo: "modelcontextprotocol/servers/src/memory", trust: "Reference", best_practice: "用于持久化上下文，而非主数据存储" },
+                { name: "Chroma MCP", purpose: "向量数据库，用于嵌入", repo: "chroma-core/chroma-mcp", trust: "Official (515 stars)", best_practice: "用于语义搜索；保持集合范围明确" },
+            ],
+            skills: [
+                { name: "xlsx", what_it_teaches: "Excel 电子表格创建、公式、图表", source: "Anthropic", best_practice: "验证公式；使用命名范围" },
+                { name: "sql-optimization", what_it_teaches: "SQL 查询性能优化", source: "GitHub", best_practice: "优化前先用 EXPLAIN 分析查询" },
+            ],
+            progression: "Filesystem → Memory → Chroma",
+            notes: null,
+        },
+        "DevOps & Infrastructure": {
+            description: "CI/CD、部署、监控、基础设施即代码",
+            mcps: [
+                { name: "GitHub MCP", purpose: "通过 GitHub Actions 实现 CI/CD", repo: "github/github-mcp-server", trust: "Official (28K stars)", best_practice: "合并前审查工作流变更" },
+                { name: "Terraform MCP", purpose: "基础设施即代码", repo: "hashicorp/terraform-mcp-server", trust: "Official (1.3K stars)", best_practice: "apply 前务必先运行 plan" },
+                { name: "AWS MCP", purpose: "Lambda、S3、云服务", repo: "awslabs/mcp", trust: "Official (8.5K stars)", best_practice: "使用最小权限 IAM 角色" },
+                { name: "Cloudflare MCP", purpose: "Workers、边缘计算、CDN、DNS", repo: "cloudflare/mcp-server-cloudflare", trust: "Official (3.5K stars)", best_practice: "部署前先在本地测试 Workers" },
+                { name: "Grafana MCP", purpose: "可观测性仪表板", repo: "grafana/mcp-grafana", trust: "Official (2.5K stars)", best_practice: "建议智能体使用只读权限" },
+                { name: "Docker MCP", purpose: "容器管理", repo: "docker/mcp-gateway", trust: "Official (1.3K stars)", best_practice: "不要将 Docker socket 暴露给不可信的智能体" },
+            ],
+            skills: [
+                { name: "devops-rollout-plan", what_it_teaches: "规划安全的生产环境发布", source: "GitHub", best_practice: "包含回滚步骤；使用金丝雀部署" },
+                { name: "multi-stage-dockerfile", what_it_teaches: "优化 Docker 镜像", source: "GitHub", best_practice: "最小化镜像体积；排除开发依赖" },
+                { name: "cloud-design-patterns", what_it_teaches: "云架构模式（重试、熔断器）", source: "GitHub", best_practice: "根据需求选择合适的模式" },
+            ],
+            progression: "GitHub → AWS/Cloudflare → Terraform → Grafana → Docker",
+            notes: null,
+        },
+        "Security & Testing": {
+            description: "漏洞扫描、代码审查、质量保证",
+            mcps: [
+                { name: "Snyk Agent Scan", purpose: "AI 智能体和 MCP 的安全扫描器", repo: "snyk/agent-scan", trust: "Official (1.9K stars)", best_practice: "使用前扫描所有新安装的 MCP" },
+                { name: "Playwright MCP", purpose: "端到端安全测试", repo: "microsoft/playwright-mcp", trust: "Official (29K stars)", best_practice: "测试认证流程、输入验证、XSS 向量" },
+                { name: "GitHub MCP", purpose: "PR 安全审查", repo: "github/github-mcp-server", trust: "Official (28K stars)", best_practice: "启用分支保护；要求代码审查" },
+            ],
+            skills: [
+                { name: "agent-governance", what_it_teaches: "AI 智能体的治理策略", source: "GitHub", best_practice: "授予自主权之前先定义边界" },
+                { name: "ai-prompt-engineering-safety-review", what_it_teaches: "审查提示词的注入风险", source: "GitHub", best_practice: "部署前检查所有面向用户的提示词" },
+            ],
+            progression: "Filesystem → Snyk → GitHub PR review → Playwright E2E",
+            notes: null,
+        },
+        "Design & Visual": {
+            description: "UI/UX、图表、视觉资源",
+            mcps: [
+                { name: "Playwright MCP", purpose: "视觉测试、截图对比", repo: "microsoft/playwright-mcp", trust: "Official (29K stars)", best_practice: "用于 UI 测试和视觉回归测试" },
+            ],
+            skills: [
+                { name: "canvas-design", what_it_teaches: "使用 canvas 进行视觉设计", source: "Anthropic", best_practice: "遵循品牌规范；保持一致性" },
+                { name: "brand-guidelines", what_it_teaches: "创建并遵循品牌标识", source: "Anthropic", best_practice: "先定义颜色、字体、间距" },
+                { name: "theme-factory", what_it_teaches: "生成一致的 UI 主题", source: "Anthropic", best_practice: "支持明暗模式；使用 CSS 变量" },
+            ],
+            progression: "Playwright → canvas-design → brand-guidelines → theme-factory",
+            notes: "Canva、Excalidraw、Blender 和 Mermaid 尚无官方 MCP 服务器。",
+        },
+        "Research & Knowledge": {
+            description: "文献综述、事实核查、来源评估、信息综合",
+            mcps: [
+                { name: "Brave Search MCP", purpose: "隐私优先的网络搜索", repo: "brave/brave-search-mcp-server", trust: "Official (775 stars)", best_practice: "始终标注来源；交叉验证信息" },
+                { name: "Fetch MCP", purpose: "读取网页、提取内容", repo: "modelcontextprotocol/servers/src/fetch", trust: "Reference", best_practice: "将 HTML 转为 markdown 以获得更干净的内容" },
+                { name: "Memory MCP", purpose: "持久化知识图谱", repo: "modelcontextprotocol/servers/src/memory", trust: "Reference", best_practice: "结构化实体和关系" },
+            ],
+            skills: [
+                { name: "remember", what_it_teaches: "智能体的持久记忆模式", source: "GitHub", best_practice: "存储结构化发现，而非原始数据" },
+                { name: "create-technical-spike", what_it_teaches: "限时技术调研", source: "GitHub", best_practice: "预先定义成功标准" },
+                { name: "context-map", what_it_teaches: "在复杂领域中映射上下文关系", source: "GitHub", best_practice: "深入研究前先识别有界上下文" },
+            ],
+            progression: "Brave Search + Fetch → Memory",
+            notes: null,
+        },
+        "Writing & Content": {
+            description: "技术写作、文案、文档、编辑",
+            mcps: [
+                { name: "Filesystem MCP", purpose: "读写文档", repo: "modelcontextprotocol/servers/src/filesystem", trust: "Reference", best_practice: "使用统一的文件命名；为重要文档做版本管理" },
+                { name: "Notion MCP", purpose: "知识库、文档、Wiki", repo: "makenotion/notion-mcp-server", trust: "Official (4K stars)", best_practice: "使用限定特定页面范围的 API token" },
+                { name: "ElevenLabs MCP", purpose: "内容文本转语音", repo: "elevenlabs/elevenlabs-mcp", trust: "Official (1.3K stars)", best_practice: "选择合适的语音；发布前审听音频" },
+            ],
+            skills: [
+                { name: "doc-coauthoring", what_it_teaches: "协作文档编写", source: "Anthropic", best_practice: "保持一致的语气；跟踪修改" },
+                { name: "docx", what_it_teaches: "带格式的 Word 文档创建", source: "Anthropic", best_practice: "统一使用样式" },
+                { name: "documentation-writer", what_it_teaches: "技术文档编写最佳实践", source: "GitHub", best_practice: "根据读者水平写作；包含代码示例" },
+                { name: "create-readme", what_it_teaches: "生成全面的 README 文档", source: "GitHub", best_practice: "包含安装、用法和贡献指南" },
+            ],
+            progression: "Filesystem + Notion → ElevenLabs",
+            notes: null,
+        },
+        "Communication & Collaboration": {
+            description: "团队协调、状态更新、异步沟通",
+            mcps: [
+                { name: "Notion MCP", purpose: "共享文档", repo: "makenotion/notion-mcp-server", trust: "Official (4K stars)", best_practice: "仅将集成范围限定在团队工作空间" },
+                { name: "Atlassian MCP", purpose: "Jira 问题、Confluence 文档", repo: "atlassian/atlassian-mcp-server", trust: "Official (436 stars)", best_practice: "以只读为主；状态变更需经审批" },
+            ],
+            skills: [
+                { name: "internal-comms", what_it_teaches: "内部沟通写作", source: "Anthropic", best_practice: "语气匹配受众；简明扼要" },
+                { name: "meeting-minutes", what_it_teaches: "记录和整理会议纪要", source: "GitHub", best_practice: "包含责任人和截止日期的待办事项" },
+            ],
+            progression: "Notion → Atlassian",
+            notes: "Gmail、Slack、Discord 尚无其官方公司发布的 MCP 服务器。",
+        },
+        "Project Management": {
+            description: "规划、任务跟踪、路线图",
+            mcps: [
+                { name: "GitHub MCP", purpose: "Issue、里程碑、项目看板", repo: "github/github-mcp-server", trust: "Official (28K stars)", best_practice: "统一使用标签和里程碑" },
+                { name: "Notion MCP", purpose: "项目 Wiki、数据库", repo: "makenotion/notion-mcp-server", trust: "Official (4K stars)", best_practice: "使用一致的 schema 结构化数据库" },
+                { name: "Atlassian MCP", purpose: "Jira 冲刺、看板", repo: "atlassian/atlassian-mcp-server", trust: "Official (436 stars)", best_practice: "遵循团队现有的工作流" },
+                { name: "Memory MCP", purpose: "跨会话跟踪决策", repo: "modelcontextprotocol/servers/src/memory", trust: "Reference", best_practice: "记录关键决策的理由和日期" },
+            ],
+            skills: [
+                { name: "breakdown-epic-pm", what_it_teaches: "将 Epic 拆解为可管理的用户故事", source: "GitHub", best_practice: "每个故事应可独立交付" },
+                { name: "prd", what_it_teaches: "编写产品需求文档", source: "GitHub", best_practice: "定义用户故事、验收标准和范围" },
+                { name: "create-architectural-decision-record", what_it_teaches: "记录架构决策（ADR）", source: "GitHub", best_practice: "记录上下文、决策和影响" },
+            ],
+            progression: "GitHub issues + Notion → Atlassian → Memory",
+            notes: null,
+        },
+        "Database & Backend": {
+            description: "Schema 设计、查询优化、数据迁移",
+            mcps: [
+                { name: "MongoDB MCP", purpose: "文档数据库操作", repo: "mongodb-js/mongodb-mcp-server", trust: "Official (959 stars)", best_practice: "从环境变量读取连接字符串；绝不硬编码凭证" },
+                { name: "Chroma MCP", purpose: "向量数据库，用于嵌入", repo: "chroma-core/chroma-mcp", trust: "Official (515 stars)", best_practice: "按项目划分集合范围" },
+                { name: "Stripe MCP", purpose: "支付集成和数据", repo: "stripe/ai", trust: "Official (1.4K stars)", best_practice: "开发时使用测试密钥；绝不记录支付数据" },
+            ],
+            skills: [
+                { name: "postgresql-optimization", what_it_teaches: "PostgreSQL 查询和 schema 优化", source: "GitHub", best_practice: "使用 EXPLAIN ANALYZE；根据查询模式添加索引" },
+                { name: "cosmosdb-datamodeling", what_it_teaches: "NoSQL 数据建模模式", source: "GitHub", best_practice: "面向访问模式设计，而非范式化" },
+            ],
+            progression: "MongoDB → Chroma → Stripe",
+            notes: "Supabase 和 PostgreSQL 尚无官方 MCP 服务器。",
+        },
+        "Cloud & Platform": {
+            description: "云服务、无服务器、边缘计算、弹性扩展",
+            mcps: [
+                { name: "AWS MCP", purpose: "Lambda、S3、EC2，完整 AWS 套件", repo: "awslabs/mcp", trust: "Official (8.5K stars)", best_practice: "使用最小权限 IAM 角色；定期轮换凭证" },
+                { name: "Cloudflare MCP", purpose: "Workers、边缘计算、CDN、DNS", repo: "cloudflare/mcp-server-cloudflare", trust: "Official (3.5K stars)", best_practice: "部署前使用 wrangler 本地测试 Workers" },
+                { name: "Terraform MCP", purpose: "多云基础设施即代码", repo: "hashicorp/terraform-mcp-server", trust: "Official (1.3K stars)", best_practice: "使用远程状态；操作时锁定状态" },
+                { name: "Docker MCP", purpose: "容器编排", repo: "docker/mcp-gateway", trust: "Official (1.3K stars)", best_practice: "多容器用 Docker Compose；不要以 root 运行" },
+            ],
+            skills: [
+                { name: "azure-static-web-apps", what_it_teaches: "将静态 Web 应用部署到云端", source: "GitHub", best_practice: "使用预发布环境；配置自定义域名" },
+                { name: "containerize-aspnetcore", what_it_teaches: "将应用容器化部署到云端", source: "GitHub", best_practice: "使用多阶段构建；最小化镜像体积" },
+            ],
+            progression: "Docker → AWS/Cloudflare → Terraform",
+            notes: null,
+        },
+        "AI & Machine Learning": {
+            description: "模型训练、提示词工程、智能体编排",
+            mcps: [
+                { name: "Sequential Thinking MCP", purpose: "复杂的多步推理", repo: "modelcontextprotocol/servers/src/sequentialthinking", trust: "Reference", best_practice: "用于规划和分解，而非简单查询" },
+                { name: "Memory MCP", purpose: "跨会话持久化知识", repo: "modelcontextprotocol/servers/src/memory", trust: "Reference", best_practice: "以知识图谱形式结构化；清理过期条目" },
+                { name: "Chroma MCP", purpose: "向量数据库，用于嵌入", repo: "chroma-core/chroma-mcp", trust: "Official (515 stars)", best_practice: "使用合适的嵌入模型；监控集合大小" },
+            ],
+            skills: [
+                { name: "claude-api", what_it_teaches: "使用 Claude API 构建应用", source: "Anthropic", best_practice: "长响应使用流式传输；处理速率限制" },
+                { name: "mcp-builder", what_it_teaches: "从零开始构建 MCP 服务器", source: "Anthropic", best_practice: "遵循规范；使用 MCP inspector 验证" },
+                { name: "prompt-builder", what_it_teaches: "编写高效的提示词", source: "GitHub", best_practice: "具体明确；提供示例；约束输出格式" },
+                { name: "agentic-eval", what_it_teaches: "评估智能体 AI 系统", source: "GitHub", best_practice: "定义明确的成功指标；测试对抗性输入" },
+            ],
+            progression: "Sequential Thinking + Memory → Chroma",
+            notes: null,
+        },
+        "Marketing & SEO": {
+            description: "SEO、竞品分析、内容策略",
+            mcps: [
+                { name: "Firecrawl MCP", purpose: "SEO 审计、竞品网站爬取", repo: "firecrawl/firecrawl-mcp-server", trust: "Official (5.8K stars)", best_practice: "遵守速率限制；仅爬取自有或已授权的网站" },
+                { name: "Brave Search MCP", purpose: "市场调研、趋势分析", repo: "brave/brave-search-mcp-server", trust: "Official (775 stars)", best_practice: "使用日期过滤器进行趋势研究" },
+                { name: "Notion MCP", purpose: "内容日历、策略文档", repo: "makenotion/notion-mcp-server", trust: "Official (4K stars)", best_practice: "为周期性内容工作流创建模板" },
+            ],
+            skills: [],
+            progression: "Brave Search → Firecrawl → Notion",
+            notes: null,
+        },
+        "Finance & Commerce": {
+            description: "金融数据、支付、定价、市场分析",
+            mcps: [
+                { name: "Stripe MCP", purpose: "支付集成和计费", repo: "stripe/ai", trust: "Official (1.4K stars)", best_practice: "开发时始终使用测试密钥；不记录 PCI 数据" },
+                { name: "Brave Search MCP", purpose: "市场调研、财经新闻", repo: "brave/brave-search-mcp-server", trust: "Official (775 stars)", best_practice: "从多个来源交叉验证金融数据" },
+            ],
+            skills: [],
+            progression: "Fetch (financial APIs) → Brave Search → Stripe",
+            notes: null,
+        },
+        "Science & Life Sciences": {
+            description: "科研、数据分析、文献综述、生物信息学",
+            mcps: [
+                { name: "Fetch MCP", purpose: "访问 PubMed、NCBI 等 API", repo: "modelcontextprotocol/servers/src/fetch", trust: "Reference", best_practice: "使用结构化 API 端点（PubMed E-utilities）" },
+                { name: "Memory MCP", purpose: "跨会话跟踪研究发现", repo: "modelcontextprotocol/servers/src/memory", trust: "Reference", best_practice: "将引用元数据与研究发现一同存储" },
+            ],
+            skills: [],
+            progression: "Fetch (PubMed API) → Memory",
+            notes: "文献综述工作流请参考 Research & Knowledge 技能（第 7 类）。",
+        },
+        "Culture & Creative": {
+            description: "艺术策展、文化知识、娱乐、创意项目",
+            mcps: [
+                { name: "Fetch MCP", purpose: "访问博物馆 API（Met、Smithsonian）", repo: "modelcontextprotocol/servers/src/fetch", trust: "Reference", best_practice: "使用官方 REST API" },
+                { name: "ElevenLabs MCP", purpose: "创意项目音频", repo: "elevenlabs/elevenlabs-mcp", trust: "Official (1.3K stars)", best_practice: "语音风格匹配项目基调" },
+            ],
+            skills: [
+                { name: "algorithmic-art", what_it_teaches: "通过代码和算法生成艺术作品", source: "Anthropic", best_practice: "尝试不同参数；记录有趣的种子值" },
+                { name: "game-engine", what_it_teaches: "游戏开发模式", source: "GitHub", best_practice: "从原型开始；迭代优化玩法" },
+            ],
+            progression: "Fetch (museum APIs) → ElevenLabs",
+            notes: null,
+        },
+    };
+    server.registerTool("levelup_browse_skillsets", {
+        title: "浏览推荐技能集",
+        description: `浏览任意能力类别的推荐 MCP（工具）和技能（知识）。
+
+返回某个能力的官方推荐配置——需要安装哪些 MCP、
+学习哪些技能、进阶路径以及每项的最佳实践。
+
+用途：
+- 了解特定领域需要哪些工具
+- 获取推荐的学习路径
+- 查找每个 MCP 的最佳实践
+
+使用 ability="all" 查看所有类别，或指定如 "Software Engineering"。
+
+参数:
+  - ability (string): 能力名称（如 "Software Engineering"、"Web Development"）或 "all" 查看总览。
+
+返回:
+  MCP 及其仓库、信任等级和最佳实践。
+  技能及其来源和最佳实践。
+  进阶路径和备注。`,
+        inputSchema: {
+            ability: z.string().describe('能力类别名称（如 "Software Engineering"、"DevOps & Infrastructure"）或 "all" 查看总览'),
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, (growthPlanHandlers.bs = async (params) => {
+        const query = params.ability.toLowerCase().trim();
+        if (query === "all" || query === "list" || query === "overview") {
+            const overview = Object.entries(SKILLSET_DATA).map(([name, data]) => ({
+                ability: name,
+                description: data.description,
+                mcp_count: data.mcps.length,
+                skill_count: data.skills.length,
+                progression: data.progression,
+            }));
+            return toMcpResponse(ok({
+                total_abilities: overview.length,
+                abilities: overview,
+                skill_sources: [
+                    { name: "anthropics/skills", publisher: "Anthropic", url: "https://github.com/anthropics/skills", description: "官方 SKILL.md 格式——17 个生产级技能" },
+                    { name: "github/awesome-copilot", publisher: "GitHub", url: "https://github.com/github/awesome-copilot/tree/main/skills", description: "222 个 Copilot 社区技能（兼容任何智能体）" },
+                ],
+                tip: "使用具体的能力名称再次调用，查看完整的 MCP + 技能推荐。",
+            }));
+        }
+        // Fuzzy match on ability name
+        const match = Object.entries(SKILLSET_DATA).find(([name]) => name.toLowerCase().includes(query) || query.includes(name.toLowerCase()));
+        if (!match) {
+            const available = Object.keys(SKILLSET_DATA).join(", ");
+            return toMcpResponse(fail(`未找到匹配 "${params.ability}" 的能力`, `可用能力：${available}`));
+        }
+        const [abilityName, data] = match;
+        return toMcpResponse(ok({
+            ability: abilityName,
+            description: data.description,
+            mcps: data.mcps.map((m) => ({
+                ...m,
+                install_url: `https://github.com/${m.repo}`,
+            })),
+            skills: data.skills.map((s) => ({
+                ...s,
+                install_url: s.source === "Anthropic"
+                    ? `https://github.com/anthropics/skills/tree/main/skills/${s.name}`
+                    : `https://github.com/github/awesome-copilot/tree/main/skills/${s.name}`,
+            })),
+            progression: data.progression,
+            notes: data.notes,
+            how_to_install: "安装 MCP 或技能后，使用 levelup_install_agent_skill 进行注册。",
+        }));
+    }));
+    logRegistered("levelup_browse_skillsets");
+    console.error(`  → 2 of 2 growth plan tools registered ✅`);
+}
+//# sourceMappingURL=growth-plan.js.map