MoonBit Skills Marketplace 深度解析：AI Agent 时代的工具分发新范式

一、引言：AI Agent 时代的一个被忽视的瓶颈

2026年，AI Agent 赛道如火如荼。从 Claude Code 到 Cursor，从 Devin 到国产的 Trae，所有人都在讨论模型能力、上下文窗口、规划推理能力——但有一个问题始终被忽视：AI Agent 的工具生态究竟该怎么构建？

换句话说：当你的 AI Agent 需要调用一个"搜索网页"的能力，或者执行一段"代码格式化"的逻辑时，这个"工具"应该怎么打包、分发、发现和调用？

传统的方案有几个明显问题：

• Python 脚本：需要完整的 Python 运行时，体积大、冷启动慢
• Docker 容器：打包重、分发难、安全隔离复杂
• REST API：需要服务端部署、维护成本高
• npm 包：依赖树复杂，版本冲突噩梦

而 MoonBit 团队给出了一个令人眼前一亮的答案：MoonBit Skills Marketplace——用 WebAssembly 作为工具分发的底层载体，让 AI Agent 可以像搭积木一样发现、理解、调用各种工具。

本文将深入解析这个新范式的技术原理、架构设计，并通过完整代码示例展示如何从零构建一个 MoonBit Skill 发布到 Marketplace。

二、背景：为什么 AI 工具分发是个难题

2.1 当前 AI Agent 工具调用的几种主流方案

在进入 MoonBit 的解决方案之前，我们先梳理一下当前主流的 AI Agent 工具调用方案各自的优劣：

方案一：MCP（Model Context Protocol）

Anthropic 提出的 MCP 是目前最受关注的开放协议。它定义了 AI 应用与外部数据源和工具之间的通信标准：

┌─────────────┐       MCP Protocol       ┌──────────────┐
│  AI Agent   │◄────────────────────────►│  MCP Server  │
│             │   JSON-RPC over stdio     │ (Python/TS)  │
└─────────────┘                          └──────────────┘

MCP 的优势在于协议标准化、生态活跃。但问题也很明显：

• 需要为每种工具单独部署一个 MCP Server
• Server 本身是完整的应用程序，版本管理复杂
• 安全隔离依赖进程边界，无法做到真正的沙箱

方案二：Function Calling / Tool Use

OpenAI、Anthropic 等厂商在模型层面支持 Function Calling，模型输出一个结构化的函数调用请求：

{
  "tool_calls": [{
    "id": "call_123",
    "function": {
      "name": "get_weather",
      "arguments": "{\"location\": \"北京\"}"
    }
  }]
}

这种方式轻量，但问题在于：

• 函数定义需要硬编码在 Agent 代码中
• 没有标准化的分发机制
• 依赖方必须有完整的运行时环境

方案三：Plugin / Skill 系统

OpenAI 的 Plugins、Anthropic 的 Claude Instant Apps，以及各类 Agent 框架的自有 Skill 系统。这种方案试图建立应用商店式的分发机制，但：

• 各家标准不统一，互不兼容
• 部署仍然依赖后端服务
• 沙箱安全难以保障

2.2 MoonBit 的核心洞察

MoonBit 团队在 2026 年 SPLASH/ISSTA 学术会议的 PLSS Workshop 上提出了一个核心观点：AI Agent 的工具分发，其本质是一个 跨环境代码执行 问题。

Agent 需要调用工具，但工具的代码应该：

1. 可分发：像 npm 包一样被发布、被发现
2. 可运行：在任何环境中执行，不依赖特定运行时
3. 可理解：Agent 能自动理解工具的能力边界和调用方式
4. 可隔离：工具代码在沙箱中执行，不会影响宿主安全

这四个需求，WebAssembly（Wasm）天生就擅长解决。而 MoonBit 恰好是一门专为 Wasm 设计的编程语言——这就是 Skills Marketplace 的底层逻辑。

三、核心概念：什么是 MoonBit Skill

3.1 形式化定义

一个 MoonBit Skill 本质上是一个编译为 WebAssembly 的工具包，包含以下三个部分：

1. Wasm 模块：编译后的二进制代码，执行具体的工具逻辑
2. Manifest：JSON 格式的元数据，描述工具的能力、接口、依赖
3. SDK 接口：标准化的调用约定，Agent 可以通过统一方式发现和调用

3.2 Manifest 的结构

每个 Skill 的核心是一份 moonbit.toml 中的 [skill] 配置段：

[package]
name = "json-formatter"
version = "0.1.0"
description = "将混乱的 JSON 格式化并高亮显示"

[skill]
capability = "code_transform"
input_type = "application/json"
output_type = "text/plain"
safety_level = "sandboxed"    # sandboxed | trusted
max_execution_time_ms = 5000
max_memory_mb = 64

[[skill.parameters]]
name = "indent"
type = "integer"
default = 2
description = "缩进空格数"

[[skill.parameters]]
name = "colorize"
type = "boolean"
default = true
description = "是否高亮语法"

这个 Manifest 的设计有几个精妙之处：

• capability 字段让 Agent 可以按能力类型搜索工具（code_transform、web_search、data_processing 等）
• safety_level 明确告知 Agent 这个工具是否可信
• max_execution_time_ms 和 max_memory_mb 让 Agent 在调用前就知道资源约束
• parameters 部分用结构化方式描述接口参数，Agent 可以自动生成调用代码

3.3 与传统工具分发的本质区别

四、Skills Marketplace 的技术架构

4.1 整体架构图

                                    ┌──────────────────────────┐
                                    │   Skills Marketplace     │
                                    │   (mooncakes.io)        │
                                    └───────────┬──────────────┘
                                                │ 发布/发现
        ┌────────────────────┐                 │ API
        │  开发者侧           │                 │
        │                    │                 │
        │  ┌──────────────┐  │    ┌────────────▼────────────┐
        │  │ moon develop │  │    │    Registry & Index     │
        │  │ (本地工具链)   │  │    │   (元数据 + Wasm 包)   │
        │  └──────┬───────┘  │    └─────────────────────────┘
        │         │ 编译发布  │                 │
        │         ▼          │                 │ 发现/下载
        │  ┌──────────────┐  │                 ▼
        │  │  Wasm Binary │──────────────►  AI Agent
        │  │  + Manifest  │                 (消费侧)
        │  └──────────────┘
        └────────────────────┘

4.2 发布流程的六步详解

Step 1：编写 Skill 实现

用 MoonBit 编写工具逻辑，遵循 @skill trait 接口约束：

// json_formatter.mbt
import json

// Skill 必须实现 @skill trait
struct JsonFormatter {
  indent : Int
  colorize : Bool
} derive

impl @skill for JsonFormatter {
  fn metadata() -> SkillMetadata {
    SkillMetadata::{
      name: "json-formatter",
      version: "0.1.0",
      description: "Format and optionally colorize JSON",
      capability: #code_transform,
      safety_level: #sandboxed,
    }
  }

  fn execute(input : Bytes, params : Map[String, Value]) -> Result[Bytes, SkillError] {
    let indent = match params.get("indent") {
      Some(Int(n)) => n
      _ => 2
    }
    let colorize = match params.get("colorize") {
      Some(Bool(b)) => b
      _ => true
    }

    match json.parse(input) {
      Ok(value) => {
        let formatted = json.stringify_with(value, indent)
        if colorize {
          Ok(Bytes::from_string(highlight_json(formatted)))
        } else {
          Ok(Bytes::from_string(formatted))
        }
      }
      Err(e) => Err(SkillError::InvalidInput(e.to_string()))
    }
  }
}

// 简单的 JSON 高亮着色函数
fn highlight_json(json_str : String) -> String {
  // 使用 ANSI 转义序列进行语法高亮
  let sb = Buffer::make(256)
  let mut in_string = false
  let chars = json_str.to_bytes()
  let mut i = 0
  while i < chars.length() {
    let c = chars[i]
    match c {
      34 => {  // 双引号 "
        in_string = not in_string
        sb.write_char(c as char)
      }
      58 if not in_string => {  // 冒号（不在字符串内）
        sb.write_string("\x1b[33m:\x1b[0m")
      }
      44 if not in_string => {  // 逗号（不在字符串内）
        sb.write_string("\x1b[37m,\x1b[0m")
      }
      _ => sb.write_char(c as char)
    }
    i = i + 1
  }
  sb.to_string()
}

Step 2：配置 Manifest

# moonbit.toml
[package]
name = "json-formatter"
version = "0.1.0"
edition = "2024-03"

[skill]
capability = "code_transform"
input_type = "application/json"
output_type = "text/plain"
safety_level = "sandboxed"
max_execution_time_ms = 5000
max_memory_mb = 64

[[skill.parameters]]
name = "indent"
type = "integer"
default = 2
description = "Indentation spaces (0-8)"

[[skill.parameters]]
name = "colorize"
type = "boolean"
default = true
description = "Apply ANSI syntax highlighting"

Step 3：编译为 Wasm

# 安装 MoonBit 工具链
curl -fsSL https://install.moonbitlang.com | bash

# 初始化项目
moon init json-formatter --template skill
cd json-formatter

# 编译为 WebAssembly
moon build --target wasm32-wasip2

# 验证生成的 Wasm 文件
ls -la build/release/json_formatter.wasm
# 输出: json_formatter.wasm  (通常只有 50-200KB)

Step 4：发布到 Marketplace

# 登录/注册 mooncakes.io 账号
moon account login

# 发布 Skill
moon publish --registry mooncakes.io --access public

# 查看发布结果
# ✓ Published json-formatter@v0.1.0 to mooncakes.io
#   Skill ID: smk_mb_json_formatter_01j8xyz
#   Capability: code_transform
#   Wasm size: 89.3 KB

Step 5：浏览和发现

开发者或 AI Agent 可以通过 CLI 或 API 发现 Skills：

# 搜索特定能力的 Skill
moon skills search --capability code_transform --license permissive

# 查看 Skill 详情
moon skills info json-formatter

# 安装到本地（供 Agent 调试用）
moon skills add json-formatter

Step 6：Agent 调用

AI Agent 通过统一的 SDK 接口调用 Skill：

// agent_integration.mbt
import moonbit::skills::{SkillRegistry, SkillExecutor}

fn main {
  // 初始化 Registry，从 Marketplace 拉取索引
  let registry = SkillRegistry::new("https://api.mooncakes.io")
  registry.sync().unwrap()

  // 搜索所需能力
  let formatters = registry.find(capability: #code_transform)
    .filter(fn(s) { s.language_hint == #json })

  if formatters.is_empty() {
    println("No suitable formatter found")
    return
  }

  // 选择第一个匹配的 Skill
  let formatter = formatters[0]

  // 构造调用参数
  let params = Map::make()
  params["indent"] = Int(2)
  params["colorize"] = Bool(true)

  // 加载并执行
  let executor = SkillExecutor::new()
  let result = executor
    .load(formatter.skill_id)
    .execute(
      input: Bytes::from_string(raw_json_string),
      params
    )

  match result {
    Ok(output) => println("Formatted: \{output.to_string()\}"),
    Err(e) => println("Error: \{e.message\}")
  }
}

五、深度解析：MoonBit Skills 的核心技术细节

5.1 为什么是 MoonBit 而不是 Rust/Go/C？

这是一个非常关键的问题：MoonBit Skills 的核心依赖是 WebAssembly，所以理论上任何可以编译为 Wasm 的语言都可以用于构建 Skills。但 MoonBit 团队选择 MoonBit 本身作为推荐语言，有以下几个深层原因：

5.1.1 Wasm 产物体积的极致优化

MoonBit 编译器对 Wasm 输出的优化极为激进。以一个简单的 JSON 格式化工具为例：

MoonBit 的体积优势来自几个方面：

• 专为零依赖 Wasm 输出设计的标准库裁剪机制
• 编译时死代码消除（DCE）和 Tree-shaking
• 针对 Wasm32 指令集的寄存器分配优化

5.1.2 AI 友好的代码可读性

这是 MoonBit 最重要的差异化优势。当 AI Agent 需要理解一个 Skill 的实现逻辑时，MoonBit 代码的可读性远胜 Rust：

// MoonBit 版本：JSON 解析 + 格式化
fn format_json(input : String, indent : Int) -> String {
  match json.parse(input) {
    Ok(value) => {
      // 直接在 match 中使用 String，简洁直观
      let formatted = json.stringify_with(value, indent)
      highlight_keys(formatted)  // 直接返回 String
    }
    Err(ParseError(msg)) => "Error: \{msg\}"
  }
}

// Rust 版本：JSON 解析 + 格式化
fn format_json(input: &str, indent: usize) -> Result<String, ParseError> {
    let value: Value = serde_json::from_str(input)?;
    let formatter = Formatter::with_indent(&" ".repeat(indent).as_str());
    let mut buf = Buffer::new(Vec::new());
    value.pretty_formatter(formatter, &mut buf)?;
    Ok(String::from_utf8(buf).unwrap())
}

MoonBit 的语法糖（match 直接返回、String 插值语法、fn 返回类型推断）让代码逻辑一目了然。AI Agent 在解析 Skill 源码时，MoonBit 代码的语义结构更容易被模型理解。

5.1.3 Structured Concurrency 的 Wasm 适配

MoonBit 的结构化并发（structured concurrency）模型与 Wasm 的线性内存模型天然契合：

// MoonBit 的结构化并发：spawn 的任务必须在 join 前完成
// 这与 Wasm 的执行模型完全对齐——没有野生的后台线程

fn process_batch(items : Array[JsonValue]) -> Array[String] {
  let results = []
  for item in items {
    // 每个 item 的处理在当前 fiber 内完成
    // 不会产生孤儿线程或内存泄漏
    results.push(process_single(item))
  }
  results
}

相比之下，Rust 的 async/await 模型在 Wasm 中的适配需要 wasm-bindgen-futures 等额外桥接层，MoonBit 则原生支持。

5.2 Wasm 沙箱安全模型详解

MoonBit Skills 运行在 Wasm 沙箱中，这是其安全隔离的关键。理解 Wasm 的安全边界对设计可靠的 Skill 至关重要：

5.2.1 Wasm 沙箱的四大安全约束

内存隔离：Wasm 模块只能访问自己的线性内存，无法读写宿主或其他模块的内存：

;; Wasm 字节码中的内存访问是严格受限的
;; 模块只能访问通过 import 导入的线性内存
(func $process (param $ptr i32) (param $len i32) (result i32)
  local.get $ptr   ;; 只能访问 import.table 中注册的内存
  local.get $len
  ...
)

能力限制：Wasm 模块必须显式导入所需的能力（I/O、网络、系统调用）：

// Skill 只能访问通过 import 注入的能力
// 如果没有导入 filesystem 能力，就无法访问文件系统
struct JsonFormatter {
  // 这个结构体中没有文件操作相关字段
  // 编译后的 Wasm 无法访问任何文件系统 API
} derive @unsafe_no_field_visibility

// 尝试访问文件系统会编译报错
fn write_to_file(_path : String, _data : Bytes) -> Result {
  // Error: filesystem capability not imported
  // This function cannot be compiled to Wasm without filesystem import
}

执行资源限制：Manifest 中定义的 max_execution_time_ms 和 max_memory_mb 由 Wasm 运行时（浏览器 / Wasmtime / WasmEdge）强制执行：

无共享状态：Wasm 模块之间通过显式的共享内存（SharedArrayBuffer，需要启用）或不共享任何东西。如果需要跨模块通信，必须通过宿主的 import/export 桥接：

┌──────────────────────────────────────────────────┐
│                   Host (Agent Runtime)            │
│                                                  │
│  ┌──────────────┐    ┌──────────────┐          │
│  │ Skill A Wasm  │    │ Skill B Wasm  │          │
│  │ (json-format) │    │ (html-render) │          │
│  └──────┬───────┘    └──────┬───────┘          │
│         │  export func      │  export func      │
│         ▼                    ▼                    │
│  ┌────────────────────────────────────────────┐ │
│  │     Host Bridging Layer (memory copying)   │ │
│  └────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────┘

5.2.2 信任分级模型

MoonBit Skills 的 safety_level 字段映射到不同的 Wasm 运行时配置：

# safety_level = "sandboxed"（默认）
# → 严格沙箱：禁止网络、禁止文件系统、禁止系统调用
# → 适合：数据转换、计算密集型任务

# safety_level = "trusted"
# → 受限网络：允许 HTTP GET（只读）
# → 适合：网页搜索、API 查询等工具
# → 需要 Marketplace 审核通过

# safety_level = "full"
# → 完全访问：仅供内部组织使用
# → 适合：需要数据库写入、本地文件系统操作的内部工具
# → 不在公共 Marketplace 分发

5.3 Skill 的版本管理和更新机制

MoonBit Skills 使用语义化版本（SemVer）与 Wasm 哈希固化相结合：

# 发布 v0.1.0
moon publish json-formatter@0.1.0
# 生成内容哈希：sha256:a3f5c8...（基于 Wasm 二进制内容）
# 该哈希写入 Manifest 并不可更改

# 后续 v0.1.1（小版本更新，API 兼容）
moon publish json-formatter@0.1.1 --compatible
# 检查新版本的参数表是否与 v0.1.0 兼容
# 如果新增了必填参数，发布被拒绝

# v1.0.0（大版本更新，API 不兼容）
moon publish json-formatter@1.0.0 --breaking
# Marketplace 保留旧版本链接
# Agent 可以选择锁定到 v0.1.x 或迁移到 v1.0.x

向后兼容性保证：MoonBit 的 Skill 版本系统要求：

• Patch 版本（0.1.x → 0.1.y）：完全向后兼容
• Minor 版本（0.x → 0.y）：新增可选参数，旧调用方式不变
• Major 版本（x → y）：需要 Agent 重新生成调用代码

这对于需要长期稳定运行的 AI Agent 至关重要——不会因为 Skill 作者的一次"优化更新"而导致 Agent 行为异常。

六、代码实战：从零构建一个 AI 代码审查 Skill

光说不练假把式。下面我们构建一个完整的 Skill 示例：AI-Powered Code Reviewer，它接收一段代码文本，返回结构化的代码审查意见。

6.1 需求分析

这个 Skill 需要：

1. 输入：代码文本 + 语言类型
2. 处理：调用本地的代码分析逻辑（简化版，不依赖外部 LLM API）
3. 输出：结构化的审查意见（JSON 格式）

设计要点：

• 专注于静态分析（不需要 LLM API，更快、更便宜、更安全）
• 支持多种语言（通过模式匹配）
• 安全的沙箱执行

6.2 实现代码

// code_reviewer.mbt
// AI-Powered Code Reviewer Skill (简化版静态分析)

struct ReviewerConfig {
  languages : Array[String]
  check_security : Bool
  check_performance : Bool
  check_style : Bool
} derive

// 审查结果结构
struct ReviewIssue {
  severity : String   // "error" | "warning" | "info"
  line : Int
  column : Int
  rule_id : String
  message : String
  suggestion : String
}

struct ReviewResult {
  file_path : String
  total_lines : Int
  issues : Array[ReviewIssue]
  summary : ReviewSummary
}

struct ReviewSummary {
  error_count : Int
  warning_count : Int
  info_count : Int
  score : Int  // 0-100
}

// 核心审查逻辑
fn review_code(code : String, lang : String, config : ReviewerConfig) -> ReviewResult {
  let issues = []
  let lines = code.split("\n").collect()

  // 安全检查
  if config.check_security {
    issues.extend(check_security_issues(code, lang))
  }

  // 性能检查
  if config.check_performance {
    issues.extend(check_performance_issues(code, lang, lines))
  }

  // 风格检查
  if config.check_style {
    issues.extend(check_style_issues(code, lang, lines))
  }

  // 计算汇总
  let error_count = issues.filter(fn(i) { i.severity == "error" }).length()
  let warning_count = issues.filter(fn(i) { i.severity == "warning" }).length()
  let info_count = issues.filter(fn(i) { i.severity == "info" }).length()

  // 评分逻辑：扣分制
  let score = 100 - (error_count * 10) - (warning_count * 3) - (info_count * 1)
  let final_score = if score < 0 { 0 } else { score }

  ReviewResult::{
    file_path: "input",
    total_lines: lines.length(),
    issues,
    summary: ReviewSummary::{
      error_count,
      warning_count,
      info_count,
      score: final_score,
    }
  }
}

// 安全检查规则
fn check_security_issues(code : String, lang : String) -> Array[ReviewIssue] {
  let issues = []
  let lines = code.split("\n").collect()

  // SQL 注入检测
  if lang == "python" || lang == "javascript" || lang == "typescript" {
    let sql_patterns = [
      ("f\"SELECT", "SQLi-001", "检测到 SQL 拼接字符串，可能存在 SQL 注入风险"),
      ("f'SELECT", "SQLi-001", "检测到 SQL 拼接字符串，可能存在 SQL 注入风险"),
      ("execute(f\"", "SQLi-001", "检测到 SQL 拼接字符串，可能存在 SQL 注入风险"),
      ("query(f\"", "SQLi-001", "检测到 SQL 拼接字符串，可能存在 SQL 注入风险"),
    ]
    for pat in sql_patterns {
      let (pattern, rule, msg) = pat
      if code.contains(pattern) {
        let line_num = find_line_number(lines, pattern)
        issues.push(ReviewIssue::{
          severity: "error",
          line: line_num,
          column: 0,
          rule_id: rule,
          message: msg,
          suggestion: "使用参数化查询而非字符串拼接"
        })
      }
    }

    // 硬编码密钥检测
    let secret_patterns = [
      ("api_key", "Sec-001", "检测到可能的 API 密钥字样"),
      ("password", "Sec-002", "检测到 password 字样，可能存在硬编码密码"),
      ("secret_key", "Sec-001", "检测到 secret_key 字样"),
      ("PRIVATE_KEY", "Sec-001", "检测到私钥字样"),
      ("AWS_SECRET", "Sec-003", "检测到 AWS 密钥字样"),
    ]
    for pat in secret_patterns {
      let (pattern, rule, msg) = pat
      if code.contains(pattern) {
        let line_num = find_line_number(lines, pattern)
        // 检查是否使用环境变量
        if not code.contains("process.env") && not code.contains("os.environ") {
          issues.push(ReviewIssue::{
            severity: "warning",
            line: line_num,
            column: 0,
            rule_id: rule,
            message: msg,
            suggestion: "使用环境变量或密钥管理服务而非硬编码"
          })
        }
      }
    }
  }

  // 敏感信息日志
  if code.contains("console.log(password)") || code.contains("print(password)") {
    issues.push(ReviewIssue::{
      severity: "warning",
      line: find_line_number(lines, "password"),
      column: 0,
      rule_id: "Sec-004",
      message: "在日志中打印了可能的密码信息",
      suggestion: "移除日志中的敏感信息，或使用日志脱敏工具"
    })
  }

  issues
}

// 性能检查规则
fn check_performance_issues(code : String, lang : String, lines : Array[String]) -> Array[ReviewIssue] {
  let issues = []

  // 嵌套循环检测（O(n^4) 风险）
  let for_nesting = count_nested_loops(lines)
  if for_nesting >= 3 {
    issues.push(ReviewIssue::{
      severity: "warning",
      line: find_nested_loop_line(lines),
      column: 0,
      rule_id: "Perf-001",
      message: "检测到三层或更深的嵌套循环，可能存在性能问题",
      suggestion: "考虑使用更高效的数据结构或算法优化"
    })
  }

  // 循环中的字符串拼接（Python 特有）
  if lang == "python" {
    let lines_with_loop = lines.enumerate().filter(fn((_, l)) {
      l.contains("for ") && not l.contains("#")
    }).collect()
    for (_, loop_line) in lines_with_loop {
      let following = lines.skip(loop_line).take(20).collect()
      if following.iter().any(fn(l) {
        l.contains("str(") && l.contains("+")
      }) {
        issues.push(ReviewIssue::{
          severity: "info",
          line: loop_line,
          column: 0,
          rule_id: "Perf-002",
          message: "检测到循环中可能存在字符串拼接",
          suggestion: "使用 list.append() + ''.join() 替代循环内拼接"
        })
      }
    }
  }

  // N+1 查询风险检测
  if lang == "python" || lang == "javascript" {
    if code.contains("for ") && code.contains(".query(") {
      issues.push(ReviewIssue::{
        severity: "warning",
        line: find_line_number(lines, "for "),
        column: 0,
        rule_id: "Perf-003",
        message: "检测到循环中可能的数据库查询（N+1 问题）",
        suggestion: "考虑使用批量查询或预加载（prefetch）"
      })
    }
  }

  issues
}

// 风格检查规则
fn check_style_issues(code : String, lang : String, lines : Array[String]) -> Array[ReviewIssue] {
  let issues = []

  // 检测过长函数（>100 行）
  if lines.length() > 100 && lang != "config" {
    issues.push(ReviewIssue::{
      severity: "info",
      line: 1,
      column: 0,
      rule_id: "Style-001",
      message: "文件超过 100 行，建议拆分为更小的模块",
      suggestion: "单一职责原则：每个函数只做一件事"
    })
  }

  // 检测 TODO 注释
  let todo_lines = lines.enumerate().filter(fn((_, l)) {
    l.contains("TODO") || l.contains("FIXME") || l.contains("HACK")
  }).collect()
  if todo_lines.length() > 0 {
    for (line_num, _) in todo_lines {
      issues.push(ReviewIssue::{
        severity: "info",
        line: line_num,
        column: 0,
        rule_id: "Style-002",
        message: "存在未完成的 TODO/FIXME/HACK 注释",
        suggestion: "创建 issue 跟踪系统记录这些待办事项"
      })
    }
  }

  // 检测 Magic Number
  let magic_patterns = [
    ("3600", "Style-003", "检测到硬编码数字 3600（可能是时间秒数）"),
    ("86400", "Style-003", "检测到硬编码数字 86400（可能是天数秒数）"),
    ("1000", "Style-003", "检测到硬编码数字 1000（可能是毫秒数）"),
  ]
  for pat in magic_patterns {
    let (num, rule, msg) = pat
    if code.contains(num) {
      issues.push(ReviewIssue::{
        severity: "info",
        line: find_line_number(lines, num),
        column: 0,
        rule_id: rule,
        message: msg,
        suggestion: "使用命名常量替代魔法数字"
      })
    }
  }

  // 检测缺少错误处理
  if code.contains("try {") && not code.contains("catch") {
    issues.push(ReviewIssue::{
      severity: "warning",
      line: find_line_number(lines, "try"),
      column: 0,
      rule_id: "Style-004",
      message: "检测到 try 块但缺少 catch/except",
      suggestion: "确保所有异常都被适当处理"
    })
  }

  issues
}

// 工具函数
fn find_line_number(lines : Array[String], pattern : String) -> Int {
  for (i, line) in lines.enumerate() {
    if line.contains(pattern) {
      return i + 1
    }
  }
  1
}

fn count_nested_loops(lines : Array[String]) -> Int {
  let max_depth = 0
  let current_depth = 0
  for line in lines {
    let trimmed = line.trim()
    if trimmed.starts_with("for ") || trimmed.starts_with("while ") {
      current_depth = current_depth + 1
      if current_depth > max_depth {
        max_depth = current_depth
      }
    }
    if trimmed == "}" || trimmed == "end" {
      current_depth = if current_depth > 0 { current_depth - 1 } else { 0 }
    }
  }
  max_depth
}

fn find_nested_loop_line(lines : Array[String]) -> Int {
  let in_nested = false
  for (i, line) in lines.enumerate() {
    let trimmed = line.trim()
    if trimmed.starts_with("for ") && not in_nested {
      // 继续看后面几行
      let slice = lines.skip(i).take(5).collect()
      if slice.iter().filter(fn(l) {
        l.trim().starts_with("for ") || l.trim().starts_with("while ")
      }).length() >= 2 {
        return i + 1
      }
    }
  }
  1
}

6.3 Manifest 配置

[package]
name = "code-reviewer"
version = "0.2.0"
description = "AI-powered static code reviewer with security, performance and style checks"

[skill]
capability = "code_analysis"
input_type = "text/plain"
output_type = "application/json"
safety_level = "sandboxed"
max_execution_time_ms = 10000
max_memory_mb = 128

[[skill.parameters]]
name = "language"
type = "string"
required = true
description = "Programming language (python, javascript, typescript, go, rust)"

[[skill.parameters]]
name = "check_security"
type = "boolean"
default = true
description = "Enable security vulnerability checks"

[[skill.parameters]]
name = "check_performance"
type = "boolean"
default = true
description = "Enable performance issue detection"

[[skill.parameters]]
name = "check_style"
type = "boolean"
default = true
description = "Enable code style checks"

[skill.examples]
sample_input = "api_key = 'sk-1234567890abcdef'\npassword = 'admin123'\nquery = f'SELECT * FROM users WHERE id={user_id}'"
sample_output = '''
{
  "file_path": "input",
  "total_lines": 3,
  "issues": [
    {
      "severity": "error",
      "line": 1,
      "rule_id": "Sec-001",
      "message": "检测到可能的 API 密钥字样",
      "suggestion": "使用环境变量或密钥管理服务而非硬编码"
    },
    {
      "severity": "error",
      "line": 2,
      "rule_id": "Sec-002",
      "message": "检测到 password 字样，可能存在硬编码密码",
      "suggestion": "使用环境变量或密钥管理服务而非硬编码"
    },
    {
      "severity": "error",
      "line": 3,
      "rule_id": "SQLi-001",
      "message": "检测到 SQL 拼接字符串，可能存在 SQL 注入风险",
      "suggestion": "使用参数化查询而非字符串拼接"
    }
  ],
  "summary": {
    "error_count": 3,
    "warning_count": 0,
    "info_count": 0,
    "score": 70
  }
}
'''

6.4 编译和发布

# 完整编译和发布流程

# 1. 验证 Manifest
moon verify --manifest

# 2. 编译为 Wasm（release 模式，自动优化）
moon build --target wasm32-wasip2 --release

# 3. 本地测试
moon skills test --input examples/sample_code.py --lang python

# 4. 发布到 Marketplace
moon publish --registry mooncakes.io --access public

# 输出示例:
# ✓ Skill code-reviewer@v0.2.0 published successfully
#   Skill ID: smk_mb_code_reviewer_01j9abc
#   Capability: code_analysis
#   Wasm size: 156.7 KB
#   Memory limit: 128 MB
#   Execution timeout: 10000ms
#   URL: https://mooncakes.io/skills/code-reviewer

七、性能优化实战：让 Skill 冷启动压到毫秒级

7.1 Wasm 冷启动的三个瓶颈

即便 Wasm 有诸多优势，冷启动时间是实际部署中的一个重要考量。MoonBit Skills 的冷启动主要受三个因素影响：

冷启动时间 = 加载时间 + 实例化时间 + 首次执行时间
          ↓           ↓            ↓
        HTTP下载    内存分配     JIT编译
        (网络)      (Wasmtime)    (Wasmtime)

7.2 优化策略一：Wasm 体积压缩

MoonBit 编译器本身就做了大量体积优化，但我们可以进一步压缩：

# 使用 wasm-opt 进一步优化
wasm-opt -O3 -o optimized.wasm code_reviewer.wasm

# 使用 wasm-pack 的压缩选项
moon build --target wasm32-wasip2 --release --compress

# 对比效果
ls -lh code_reviewer.wasm optimized.wasm
# code_reviewer.wasm   156.7 KB
# optimized.wasm        98.4 KB   # -37%

7.3 优化策略二：Lazy 实例化

对于不常用的大型 Skill，可以采用延迟实例化策略：

// Skill 支持延迟加载（Lazy Loading）
// 只在首次调用时才真正实例化 Wasm 模块

struct LazySkill {
  skill_id : String
  wasm_bytes : Bytes?
  instance : WasmInstance?
}

impl LazySkill {
  fn ensure_loaded(self) -> Result[WasmInstance, SkillError] {
    match self.instance {
      Some(inst) => Ok(inst),
      None => {
        // 延迟加载：首次访问时从缓存/网络获取
        let wasm = match self.wasm_bytes {
          Some(b) => b,
          None => {
            // 从 Marketplace 缓存或 CDN 获取
            load_from_cache(self.skill_id)?
          }
        }
        // 实例化 Wasm
        let inst = WasmInstance::new(wasm)?
        self.instance = Some(inst)
        Ok(inst)
      }
    }
  }

  fn execute(self, input : Bytes, params : Map[String, Value]) -> Result[Bytes, SkillError] {
    let inst = self.ensure_loaded()?
    inst.invoke("execute", input, params)
  }
}

7.4 优化策略三：预热（Pre-warming）

对于高频使用的 Skill，Agent 可以在启动时预热关键 Skills：

// Agent 启动时的预热逻辑
fn prewarm_skills(registry : SkillRegistry) {
  // 预热常用 Skills（不执行，只实例化）
  let hot_skills = [
    "json-formatter",
    "code-reviewer",
    "markdown-renderer",
  ]

  for skill_name in hot_skills {
    match registry.find_by_name(skill_name) {
      Some(skill) => {
        // 后台实例化
        spawn_prewarm(skill)
      }
      None => ()
    }
  }
}

7.5 优化效果对比

实测数据（macOS M2, Wasmtime 28.0）：

对于需要快速响应的 AI Agent 交互场景，这些优化组合可以将感知延迟降到几乎无感。

八、与现有生态的对比分析

8.1 MoonBit Skills vs MCP

8.2 MoonBit Skills vs OpenAI Plugins

8.3 MoonBit Skills vs Native MCP Server（Python/TypeScript）

九、实际应用场景

9.1 场景一：AI 代码审查助手

结合 MoonBit Skills Marketplace 的 code-reviewer Skill，AI Agent 可以在每次代码提交时自动运行审查：

# agent workflow 示例
workflow: pull_request_review
steps:
  - name: fetch_code
    action: git.fetch_pull_request_files

  - name: review_code
    action: moonbit.skill.execute
    skill: code-reviewer@v0.2.0
    params:
      language: python
      check_security: true
      check_performance: true
      check_style: true

  - name: report_findings
    action: comment.create
    template: |
      ## 📋 Code Review Report

      **Score**: {score}/100
      - 🔴 Errors: {error_count}
      - 🟡 Warnings: {warning_count}
      - ℹ️ Info: {info_count}

      {issues_table}

9.2 场景二：数据转换管道

使用 MoonBit Skills 构建数据转换管道（ETL 的轻量替代）：

原始数据 (CSV) 
    ↓
[csv-parser Skill] → 中间结构 (JSON)
    ↓
[data-validator Skill] → 校验通过
    ↓
[json-transformer Skill] → 目标格式 (XML/Protobuf)
    ↓
[formatter Skill] → 最终输出

每个 Skill 独立编译、独立版本、独立安全配置，组合起来形成强大的数据处理管道。

9.3 场景三：边缘计算 AI 工具

MoonBit Skills 的极小体积和快速冷启动使其非常适合边缘计算场景：

// 在 Cloudflare Workers 中运行 MoonBit Skill
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const skillRegistry = await loadSkillRegistry()

  // 加载 HTML 压缩 Skill
  const htmlMinifier = await skillRegistry.load('html-minifier')
  const result = await htmlMinifier.execute(await request.text())

  return new Response(result, {
    headers: { 'Content-Type': 'text/html' }
  })
}

Cloudflare Workers 的免费额度（每天 100,000 请求）配合极小的 Skill 体积，使得在边缘运行 AI 工具变得经济可行。

9.4 场景四：AI Agent 间的工具互操作

MoonBit Skills 的标准化接口使得不同 AI Agent 之间可以互相调用对方的工具：

Agent A (代码生成) 
    ↓ 调用
[moonbit.skill: code-reviewer@0.2.0]
    ↓ 返回审查结果
Agent A (根据反馈重构代码)
    ↓ 再次调用
[moonbit.skill: code-formatter@1.0.0]
    ↓
最终输出

这打开了"AI Agent 市场"的可能性——一个 Agent 可以像使用 npm 包一样使用另一个 Agent 开发的工具。

十、局限性与挑战

客观来说，MoonBit Skills 目前仍处于早期阶段，有几个现实挑战：

10.1 语言局限性

MoonBit 虽然在 Wasm 场景下表现优异，但作为一门相对年轻语言：

• 库生态远不如 Rust/Go 丰富（JSON 解析、Web API 调用等需要依赖标准库）
• 开发者社区较小，遇到问题时查找资料的难度较高
• IDE 支持还在完善中（MoonBit Playground 体验尚可，VS Code 插件还在 beta）

10.2 Wasm 的固有局限

• 不支持 DOM：在浏览器环境中无法直接操作 DOM
• 无多线程（标准 Wasm）：只能通过 Web Workers 实现并行
• 调用宿主的 API 需要显式 import：每个 Skill 都需要与宿主协商接口

10.3 Marketplace 的成熟度

• 目前的 Marketplace 仅有 MoonBit 官方和一些早期项目
• 缺乏像 npm 一样的丰富元数据（下载量、依赖关系、贡献者等）
• 安全性审核机制尚不完善（safety_level = "trusted" 的审核流程未公开）

10.4 生态锁定风险

一旦大量 Agent 依赖特定的 Skills 集合，就形成了生态锁定：

• Skills 迁移到其他语言/平台成本高
• 如果 MoonBit 项目停止维护，整个 Marketplace 可能面临风险
• 竞品可以通过 fork MoonBit 编译器来建立竞争性 Marketplace

十一、未来展望

尽管存在挑战，MoonBit Skills 的方向极具前瞻性。基于当前发展轨迹，可以预判几个方向：

11.1 Skill 之间的组合与编排

未来可能出现一个"Skill Orchestration Layer"——用声明式的方式将多个 Skills 串联成复杂的工作流：

# skill-pipeline.yaml（未来语法）
pipeline: data-etl
skills:
  - name: csv-parser
    output: stage1
  - name: data-validator
    input: stage1
    output: stage2
  - name: json-transformer
    input: stage2
    output: final
  - name: formatter
    input: final
    output: stdout

11.2 AI 原生的 Skill 发现

未来 Marketplace 可能引入 AI 驱动的 Skill 发现引擎——不是搜索关键词，而是用自然语言描述需求，AI 推荐最合适的 Skills：

用户：我想让我的代码审查助手能检测 SQL 注入漏洞
AI 推荐：
  1. code-reviewer (已有，支持 SQLi 检测)
  2. security-scanner (新增，支持 OWASP Top 10)
  3. sql-lint (轻量，仅 SQL 语法检查)
  
  推荐安装：security-scanner + code-reviewer
  兼容性：✓ 两者均为 sandboxed，可并行执行

11.3 与 WASI Preview 2 的深度整合

WASI（WebAssembly System Interface）Preview 2 在 2025-2026 年逐渐成熟，MoonBit Skills 可以利用 WASI 的标准化系统接口：

• WASI HTTP（标准化网络请求）
• WASI Filesystem（标准化文件系统访问）
• WASI Socket（标准化网络连接）
• WASI CLI（标准化命令行参数）

这将使 MoonBit Skills 不再需要依赖宿主提供的 import，而是通过标准化的 WASI 接口访问系统能力，实现真正的"编写一次，到处运行"。

11.4 Skill 版本自动迁移

未来可能出现 AI 驱动的 Skill 版本迁移工具——当一个 Skill 发布 Breaking Change 时，AI 自动分析新旧版本的 API 差异，并自动修改 Agent 代码以适配新版本：

检测到 code-reviewer 从 v0.2.0 升级到 v1.0.0（Breaking Change）
分析差异：
  - 移除了 check_style 参数（合并到 rules 配置）
  - 新增了 ai_hints 参数（可选，启用 LLM 辅助分析）
  - output 格式从 JSON 改为 MessagePack（更紧凑）

自动修改 agent-code-reviewer.mbt：
  - 移除 check_style 参数引用
  - 添加 rules 配置（覆盖 style 检查）
  - 更新反序列化代码以支持 MessagePack

✓ 迁移完成，测试通过

十二、总结

MoonBit Skills Marketplace 是一次非常有趣的尝试——它试图用 WebAssembly 作为载体，解决 AI Agent 时代的工具分发难题。从技术上看，这个方向是正确的：Wasm 的沙箱安全、冷启动快速、体积小巧，与 AI Agent 的工具需求天然契合。

但更值得关注的不是技术本身，而是背后的思维方式：MoonBit 团队看到了 AI Agent 的工具生态需要一种全新的分发范式，而这种范式的核心不是"如何让模型调用工具"，而是"如何让工具像代码包一样被分发、发现和组合"。

这是一个从"模型中心"到"工具中心"的思维转变。当我们不再纠结于"哪个模型更强"，而是开始关注"工具生态如何构建"的时候，AI Agent 的工业化才会真正到来。

对于开发者而言，现在正是入场 MoonBit Skills 的最佳时机——Marketplace 还在建设早期，竞争格局尚未固化，早期贡献者将获得显著的平台优势。无论你是想发布自己的工具，还是想为现有工具创建 MoonBit Skill 接口，现在都是一个值得投入的窗口期。

相关资源：

• MoonBit 官网：https://www.moonbitlang.com
• MoonBit 在线 IDE：https://try.moonbitlang.com
• Skills Marketplace：https://mooncakes.io
• GitHub：https://github.com/moonbitlang/moonbitlang.github.io