@airongrong/capability 0.0.0-stage → 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AiToEarn
+
+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.

package/README.md

@@ -1,3 +1,61 @@
-# Temporary Holding Version
+# @airongrong/capability
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`capability.yaml` 是 AiToEarn 的**能力单一事实源**：一个文件派生出五个表面，避免 GUI / MCP / SDK / OpenAPI / 校验规则各自走各自的实现。
+
+```bash
+pnpm add @airongrong/capability
+```
+
+## 用法
+
+```ts
+import { loadCapabilityManifest, generateAllSurfaces } from '@airongrong/capability'
+
+const manifest = await loadCapabilityManifest('./capability.yaml')
+const surfaces = generateAllSurfaces(manifest)
+// surfaces: { mcp, ui, openapi, sdk, validation }
+```
+
+CLI 侧一行生成五份产物：
+
+```bash
+npx @airongrong/plugin-cli cap --from ./capability.yaml --out ./generated
+```
+
+## 生成的五个表面
+
+| 表面 | 函数 | 用途 |
+| --- | --- | --- |
+| MCP tools | `generateMcpTools()` | Agent（`tools/list`）暴露的工具定义 |
+| GUI forms | `generateUiForms()` | Web/桌面端表单（小白用户轨道） |
+| OpenAPI | `generateOpenApi()` | REST 文档与服务端 stub |
+| SDK types | `generateSdkTypes()` | TS/Python 客户端类型 |
+| Validation | `generateValidationRules()` | 前后端共用校验（写操作护栏复用） |
+
+## capability.yaml 结构
+
+```yaml
+version: 1                       # 必填，整数
+actions:
+  publish_post:
+    summary: 发布图文
+    sideEffect: write            # read | draft | write
+    confirm: required            # none | required —— write 必须为 required
+    backend: [publishChannelTask]  # 契约由哪些宿主工具实现；未实现的占位条目不写
+    inputs:
+      channelId: { type: channelId, label: 渠道 }
+      text: { type: string, maxLength: 1000, label: 正文, ui: textarea }
+      dryRun: { type: boolean, default: true, hidden: true }
+    returns:
+      postId: string
+    errors: [AIT-AG-002]
+```
+
+约定：
+
+- **必填 = 没有 `default` 且没有 `hidden: true`**（`generateValidationRules()` 据此产出 `required`），
+  没有单独的 `required` 字段。
+- `type` 可取 `string | number | boolean | url | channelId | array`；`ui` 可取
+  `text | textarea | uploader | multi-select | select | switch`。
+- **写操作**（`sideEffect: write`）必须写 `confirm: required`，派生出的 MCP 工具会自动带上
+  `dryRun` 默认值，与宿主 `WriteConfirmService` 护栏对齐（错误码 `AIT-AG-002` / `AIT-AG-003`）。

package/dist/capability-generate.d.ts

@@ -0,0 +1,60 @@
+import type { CapabilityAction, CapabilityManifest } from './capability-schema';
+import { CapabilityConfirm, CapabilitySideEffect } from './capability-schema';
+export interface McpToolSpec {
+    name: string;
+    description: string;
+    sideEffect: CapabilitySideEffect;
+    confirm: CapabilityConfirm;
+    inputSchema: Record<string, unknown>;
+    errors: string[];
+    /** 契约工具对应的后端实现（未实现为 undefined），供 tools/list 过滤与路由 */
+    backend?: string[];
+}
+export interface UiFieldSpec {
+    name: string;
+    widget: string;
+    label: string;
+    required: boolean;
+    advanced: boolean;
+    maxLength?: number;
+    maxItems?: number;
+}
+export interface UiFormSpec {
+    action: string;
+    title: string;
+    confirmRequired: boolean;
+    fields: UiFieldSpec[];
+}
+export interface ValidationRule {
+    action: string;
+    required: string[];
+    maxLength: Record<string, number>;
+    maxItems: Record<string, number>;
+    formats: Record<string, string>;
+}
+/**
+ * 从能力清单生成 MCP 工具定义（§13.2 表面之二）。
+ * 写操作自动附加 dry-run 确认语义（§12.2 铁律 3、§12.4）。
+ */
+export declare function generateMcpTools(manifest: CapabilityManifest): McpToolSpec[];
+export declare function describeAction(name: string, action: CapabilityAction): string;
+/** 表面之一：GUI 表单描述（§14.2 零代码路径直接消费） */
+export declare function generateUiForms(manifest: CapabilityManifest): UiFormSpec[];
+/** 表面之三：OpenAPI 3.1 paths（供 REST 客户端与网关导入） */
+export declare function generateOpenApi(manifest: CapabilityManifest): Record<string, unknown>;
+/** 表面之四：TS SDK 类型与调用签名 */
+export declare function generateSdkTypes(manifest: CapabilityManifest): string;
+/** 表面之五：发布前校验规则（GUI、MCP、SDK 共用同一份） */
+export declare function generateValidationRules(manifest: CapabilityManifest): ValidationRule[];
+/**
+ * 一次性派生全部五种产物，保证"文档有、界面没有、SDK 不认"不再发生。
+ * 入口先过一遍 schema：缺省字段（inputs/errors/confirm）自动补默认值，
+ * 非法清单抛 PluginError 而不是在生成器深处 TypeError。
+ */
+export declare function generateAllSurfaces(manifest: CapabilityManifest): {
+    mcp: McpToolSpec[];
+    ui: UiFormSpec[];
+    openapi: Record<string, unknown>;
+    sdk: string;
+    validation: ValidationRule[];
+};

package/dist/capability-generate.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMcpTools = generateMcpTools;
+exports.describeAction = describeAction;
+exports.generateUiForms = generateUiForms;
+exports.generateOpenApi = generateOpenApi;
+exports.generateSdkTypes = generateSdkTypes;
+exports.generateValidationRules = generateValidationRules;
+exports.generateAllSurfaces = generateAllSurfaces;
+const capability_schema_1 = require("./capability-schema");
+function inputToJsonSchema(input) {
+    switch (input.type) {
+        case 'url':
+            return { type: 'string', format: 'uri' };
+        case 'channelId':
+            return { type: 'string' };
+        case 'boolean':
+            return { type: 'boolean', default: input.default };
+        case 'number':
+            return { type: 'number' };
+        case 'array':
+            return {
+                type: 'array',
+                items: input.items === 'url' ? { type: 'string', format: 'uri' } : { type: 'string' },
+                maxItems: input.maxItems,
+            };
+        default:
+            return { type: 'string', maxLength: input.maxLength };
+    }
+}
+/**
+ * 从能力清单生成 MCP 工具定义（§13.2 表面之二）。
+ * 写操作自动附加 dry-run 确认语义（§12.2 铁律 3、§12.4）。
+ */
+function generateMcpTools(manifest) {
+    return Object.entries(manifest.actions).map(([name, action]) => ({
+        name,
+        description: describeAction(name, action),
+        sideEffect: action.sideEffect,
+        confirm: action.confirm,
+        inputSchema: inputsToJsonSchema(action),
+        errors: action.errors,
+        backend: action.backend ? (Array.isArray(action.backend) ? action.backend : [action.backend]) : undefined,
+    }));
+}
+function describeAction(name, action) {
+    const parts = [action.summary];
+    if (action.sideEffect === capability_schema_1.CapabilitySideEffect.Write) {
+        parts.push('写操作：默认 dryRun 返回将发生的变更，需用户确认后才真正执行');
+    }
+    else if (action.sideEffect === capability_schema_1.CapabilitySideEffect.Draft) {
+        parts.push('产生草稿，不改变线上状态');
+    }
+    if (action.errors.length > 0) {
+        parts.push(`错误码: ${action.errors.join(', ')}`);
+    }
+    void name;
+    return parts.join('。');
+}
+function inputsToJsonSchema(action) {
+    const properties = {};
+    const required = [];
+    for (const [field, input] of Object.entries(action.inputs)) {
+        properties[field] = inputToJsonSchema(input);
+        if (input.label) {
+            properties[field] = { ...properties[field], title: input.label };
+        }
+        if (input.default !== undefined) {
+            properties[field] = { ...properties[field], default: input.default };
+        }
+        if (input.hidden) {
+            properties[field] = { ...properties[field], deprecated: true };
+        }
+        if (input.default === undefined && !input.hidden) {
+            required.push(field);
+        }
+    }
+    return { type: 'object', properties, required };
+}
+/** 表面之一：GUI 表单描述（§14.2 零代码路径直接消费） */
+function generateUiForms(manifest) {
+    return Object.entries(manifest.actions).map(([name, action]) => ({
+        action: name,
+        title: action.summary,
+        confirmRequired: action.confirm === capability_schema_1.CapabilityConfirm.Required,
+        fields: Object.entries(action.inputs)
+            .filter(([, input]) => !input.hidden)
+            .map(([field, input]) => ({
+            name: field,
+            widget: input.ui ?? widgetOf(input),
+            label: input.label ?? field,
+            required: input.default === undefined,
+            advanced: false,
+            ...(input.maxLength === undefined ? {} : { maxLength: input.maxLength }),
+            ...(input.maxItems === undefined ? {} : { maxItems: input.maxItems }),
+        })),
+    }));
+}
+function widgetOf(input) {
+    if (input.type === 'boolean') {
+        return 'switch';
+    }
+    if (input.type === 'array') {
+        return input.items === 'url' ? 'uploader' : 'multi-select';
+    }
+    if (input.type === 'url') {
+        return 'uploader';
+    }
+    return input.maxLength && input.maxLength > 200 ? 'textarea' : 'text';
+}
+/** 表面之三：OpenAPI 3.1 paths（供 REST 客户端与网关导入） */
+function generateOpenApi(manifest) {
+    const paths = {};
+    for (const [name, action] of Object.entries(manifest.actions)) {
+        paths[`/actions/${name}`] = {
+            post: {
+                'operationId': name,
+                'summary': action.summary,
+                'x-side-effect': action.sideEffect,
+                'x-confirm': action.confirm,
+                'requestBody': {
+                    required: Object.keys(action.inputs).length > 0,
+                    content: { 'application/json': { schema: inputsToJsonSchema(action) } },
+                },
+                'responses': {
+                    200: { description: 'OK' },
+                    ...(action.errors.length > 0
+                        ? { 409: { description: `业务错误: ${action.errors.join(', ')}` } }
+                        : {}),
+                },
+            },
+        };
+    }
+    return {
+        openapi: '3.1.0',
+        info: { title: 'AiToEarn Capability API', version: `v${manifest.version}` },
+        paths,
+    };
+}
+/** 表面之四：TS SDK 类型与调用签名 */
+function generateSdkTypes(manifest) {
+    const lines = [
+        '// 由 capability.yaml 自动生成，请勿手工修改',
+        '',
+        'export type CapabilityActionName =',
+        ...Object.keys(manifest.actions).map(name => `  | '${name}'`),
+        '',
+    ];
+    for (const [name, action] of Object.entries(manifest.actions)) {
+        const pascal = pascalCase(name);
+        lines.push(`export interface ${pascal}Input {`);
+        for (const [field, input] of Object.entries(action.inputs)) {
+            const optional = input.default !== undefined || input.hidden === true;
+            lines.push(`  ${field}${optional ? '?' : ''}: ${tsTypeOf(input)}`);
+        }
+        if (!('dryRun' in action.inputs)) {
+            lines.push('  dryRun?: boolean');
+        }
+        lines.push('  confirmToken?: string');
+        lines.push('}');
+        lines.push(`export interface ${pascal}Result extends Record<string, unknown> {}`);
+        lines.push('');
+    }
+    lines.push('export interface CapabilityClient {');
+    for (const name of Object.keys(manifest.actions)) {
+        const pascal = pascalCase(name);
+        lines.push(`  ${name}(input: ${pascal}Input): Promise<${pascal}Result>`);
+    }
+    lines.push('}');
+    lines.push('');
+    return lines.join('\n');
+}
+function pascalCase(name) {
+    return name
+        .split('_')
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+function tsTypeOf(input) {
+    switch (input.type) {
+        case 'boolean':
+            return 'boolean';
+        case 'number':
+            return 'number';
+        case 'array':
+            return 'string[]';
+        default:
+            return 'string';
+    }
+}
+/** 表面之五：发布前校验规则（GUI、MCP、SDK 共用同一份） */
+function generateValidationRules(manifest) {
+    return Object.entries(manifest.actions).map(([name, action]) => {
+        const required = [];
+        const maxLength = {};
+        const maxItems = {};
+        const formats = {};
+        for (const [field, input] of Object.entries(action.inputs)) {
+            if (input.default === undefined && !input.hidden) {
+                required.push(field);
+            }
+            if (input.maxLength !== undefined) {
+                maxLength[field] = input.maxLength;
+            }
+            if (input.maxItems !== undefined) {
+                maxItems[field] = input.maxItems;
+            }
+            if (input.type === 'url' || input.items === 'url') {
+                formats[field] = 'uri';
+            }
+        }
+        return { action: name, required, maxLength, maxItems, formats };
+    });
+}
+/**
+ * 一次性派生全部五种产物，保证"文档有、界面没有、SDK 不认"不再发生。
+ * 入口先过一遍 schema：缺省字段（inputs/errors/confirm）自动补默认值，
+ * 非法清单抛 PluginError 而不是在生成器深处 TypeError。
+ */
+function generateAllSurfaces(manifest) {
+    const verified = (0, capability_schema_1.verifyCapabilityManifest)(manifest);
+    return {
+        mcp: generateMcpTools(verified),
+        ui: generateUiForms(verified),
+        openapi: generateOpenApi(verified),
+        sdk: generateSdkTypes(verified),
+        validation: generateValidationRules(verified),
+    };
+}

package/dist/capability-load.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityManifest } from './capability-schema';
+/** 读取并校验 capability.yaml（§13.1 唯一事实源） */
+export declare function loadCapabilityManifest(path: string): Promise<CapabilityManifest>;

package/dist/capability-load.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCapabilityManifest = loadCapabilityManifest;
+const promises_1 = require("node:fs/promises");
+const yaml_1 = require("yaml");
+const capability_schema_1 = require("./capability-schema");
+/** 读取并校验 capability.yaml（§13.1 唯一事实源） */
+async function loadCapabilityManifest(path) {
+    const raw = await (0, promises_1.readFile)(path, 'utf8');
+    return (0, capability_schema_1.verifyCapabilityManifest)((0, yaml_1.parse)(raw));
+}

package/dist/capability-schema.d.ts

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+export declare enum CapabilitySideEffect {
+    Read = "read",
+    Draft = "draft",
+    Write = "write"
+}
+export declare enum CapabilityConfirm {
+    Required = "required",
+    None = "none"
+}
+export declare enum CapabilityUi {
+    Text = "text",
+    Textarea = "textarea",
+    Uploader = "uploader",
+    MultiSelect = "multi-select",
+    Select = "select",
+    Switch = "switch"
+}
+export declare const capabilityInputSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        url: "url";
+        channelId: "channelId";
+        array: "array";
+    }>;
+    items: z.ZodOptional<z.ZodEnum<{
+        string: "string";
+        url: "url";
+        channelId: "channelId";
+    }>>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    ui: z.ZodOptional<z.ZodEnum<{
+        text: CapabilityUi.Text;
+        textarea: CapabilityUi.Textarea;
+        uploader: CapabilityUi.Uploader;
+        "multi-select": CapabilityUi.MultiSelect;
+        select: CapabilityUi.Select;
+        switch: CapabilityUi.Switch;
+    }>>;
+    label: z.ZodOptional<z.ZodString>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const capabilityActionSchema: z.ZodObject<{
+    summary: z.ZodString;
+    sideEffect: z.ZodEnum<{
+        read: CapabilitySideEffect.Read;
+        draft: CapabilitySideEffect.Draft;
+        write: CapabilitySideEffect.Write;
+    }>;
+    confirm: z.ZodDefault<z.ZodEnum<{
+        required: CapabilityConfirm.Required;
+        none: CapabilityConfirm.None;
+    }>>;
+    backend: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            url: "url";
+            channelId: "channelId";
+            array: "array";
+        }>;
+        items: z.ZodOptional<z.ZodEnum<{
+            string: "string";
+            url: "url";
+            channelId: "channelId";
+        }>>;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        maxItems: z.ZodOptional<z.ZodNumber>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ui: z.ZodOptional<z.ZodEnum<{
+            text: CapabilityUi.Text;
+            textarea: CapabilityUi.Textarea;
+            uploader: CapabilityUi.Uploader;
+            "multi-select": CapabilityUi.MultiSelect;
+            select: CapabilityUi.Select;
+            switch: CapabilityUi.Switch;
+        }>>;
+        label: z.ZodOptional<z.ZodString>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    returns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    errors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const capabilityManifestSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    actions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        summary: z.ZodString;
+        sideEffect: z.ZodEnum<{
+            read: CapabilitySideEffect.Read;
+            draft: CapabilitySideEffect.Draft;
+            write: CapabilitySideEffect.Write;
+        }>;
+        confirm: z.ZodDefault<z.ZodEnum<{
+            required: CapabilityConfirm.Required;
+            none: CapabilityConfirm.None;
+        }>>;
+        backend: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                url: "url";
+                channelId: "channelId";
+                array: "array";
+            }>;
+            items: z.ZodOptional<z.ZodEnum<{
+                string: "string";
+                url: "url";
+                channelId: "channelId";
+            }>>;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            maxItems: z.ZodOptional<z.ZodNumber>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ui: z.ZodOptional<z.ZodEnum<{
+                text: CapabilityUi.Text;
+                textarea: CapabilityUi.Textarea;
+                uploader: CapabilityUi.Uploader;
+                "multi-select": CapabilityUi.MultiSelect;
+                select: CapabilityUi.Select;
+                switch: CapabilityUi.Switch;
+            }>>;
+            label: z.ZodOptional<z.ZodString>;
+            hidden: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        returns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        errors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CapabilityInput = z.infer<typeof capabilityInputSchema>;
+export type CapabilityAction = z.infer<typeof capabilityActionSchema>;
+export type CapabilityManifest = z.infer<typeof capabilityManifestSchema>;
+export declare function verifyCapabilityManifest(input: unknown): CapabilityManifest;

package/dist/capability-schema.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capabilityManifestSchema = exports.capabilityActionSchema = exports.capabilityInputSchema = exports.CapabilityUi = exports.CapabilityConfirm = exports.CapabilitySideEffect = void 0;
+exports.verifyCapabilityManifest = verifyCapabilityManifest;
+const plugin_api_1 = require("@airongrong/plugin-api");
+const zod_1 = require("zod");
+var CapabilitySideEffect;
+(function (CapabilitySideEffect) {
+    CapabilitySideEffect["Read"] = "read";
+    CapabilitySideEffect["Draft"] = "draft";
+    CapabilitySideEffect["Write"] = "write";
+})(CapabilitySideEffect || (exports.CapabilitySideEffect = CapabilitySideEffect = {}));
+var CapabilityConfirm;
+(function (CapabilityConfirm) {
+    CapabilityConfirm["Required"] = "required";
+    CapabilityConfirm["None"] = "none";
+})(CapabilityConfirm || (exports.CapabilityConfirm = CapabilityConfirm = {}));
+var CapabilityUi;
+(function (CapabilityUi) {
+    CapabilityUi["Text"] = "text";
+    CapabilityUi["Textarea"] = "textarea";
+    CapabilityUi["Uploader"] = "uploader";
+    CapabilityUi["MultiSelect"] = "multi-select";
+    CapabilityUi["Select"] = "select";
+    CapabilityUi["Switch"] = "switch";
+})(CapabilityUi || (exports.CapabilityUi = CapabilityUi = {}));
+exports.capabilityInputSchema = zod_1.z.object({
+    type: zod_1.z.enum(['string', 'number', 'boolean', 'url', 'channelId', 'array']),
+    items: zod_1.z.enum(['url', 'channelId', 'string']).optional(),
+    maxLength: zod_1.z.number().int().positive().optional(),
+    maxItems: zod_1.z.number().int().positive().optional(),
+    default: zod_1.z.unknown().optional(),
+    ui: zod_1.z.enum(Object.values(CapabilityUi)).optional(),
+    label: zod_1.z.string().min(1).optional(),
+    hidden: zod_1.z.boolean().optional(),
+});
+exports.capabilityActionSchema = zod_1.z.object({
+    summary: zod_1.z.string().min(1),
+    sideEffect: zod_1.z.enum(Object.values(CapabilitySideEffect)),
+    confirm: zod_1.z.enum(Object.values(CapabilityConfirm)).default(CapabilityConfirm.None),
+    /** 契约工具当前由哪些后端工具实现；未实现的契约条目无此字段 */
+    backend: zod_1.z.union([zod_1.z.string().min(1), zod_1.z.array(zod_1.z.string().min(1))]).optional(),
+    inputs: zod_1.z.record(zod_1.z.string(), exports.capabilityInputSchema).default({}),
+    returns: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    errors: zod_1.z.array(zod_1.z.string().min(1)).default([]),
+});
+exports.capabilityManifestSchema = zod_1.z.object({
+    version: zod_1.z.number().int().min(1),
+    actions: zod_1.z.record(zod_1.z.string(), exports.capabilityActionSchema),
+});
+function verifyCapabilityManifest(input) {
+    const result = exports.capabilityManifestSchema.safeParse(input);
+    if (!result.success) {
+        const issue = result.error.issues[0];
+        throw new plugin_api_1.PluginError(plugin_api_1.PluginErrorCode.InvalidManifest, `capability.yaml 非法: ${issue.path.join('.')} ${issue.message}`, { issues: result.error.issues });
+    }
+    return result.data;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './capability-generate';
+export * from './capability-load';
+export * from './capability-schema';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./capability-generate"), exports);
+__exportStar(require("./capability-load"), exports);
+__exportStar(require("./capability-schema"), exports);

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@airongrong/capability",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0-beta.1",
+  "description": "AiToEarn capability manifest: single source of truth and generators for MCP tools, GUI forms, SDK clients, OpenAPI and validation rules",
+  "license": "MIT",
+  "type": "commonjs",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yikart/aitoearn-sdk.git",
+    "directory": "packages/capability"
+  },
+  "homepage": "https://github.com/yikart/aitoearn-sdk/tree/main/packages/capability#readme",
+  "bugs": {
+    "url": "https://github.com/yikart/aitoearn-sdk/issues"
+  },
+  "keywords": [
+    "aitoearn",
+    "capability",
+    "mcp",
+    "codegen",
+    "openapi"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "node ../../scripts/prepublish-guard.mjs"
+  },
+  "dependencies": {
+    "@airongrong/plugin-api": "1.0.0-beta.0",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6"
+  }
+}