@foxian/esl 0.1.0

package/dist/vendor/core/schema/release-manifest.js

@@ -0,0 +1,161 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { SemVerSchema } from './skill-json.js';
+import { validateSkillMd } from '../skill/skill-md.js';
+const SpdxLicenseSchema = z.string().regex(/^(?:MIT|Apache-2\.0|BSD-[234]-Clause|ISC|MPL-2\.0|GPL-[23]\.0|LGPL-[23]\.0|AGPL-[23]\.0)(?:\s+(?:AND|OR)\s+(?:MIT|Apache-2\.0|BSD-[234]-Clause|ISC|MPL-2\.0|GPL-[23]\.0|LGPL-[23]\.0|AGPL-[23]\.0))*$/, { message: 'license must be an SPDX expression or LicenseRef-* identifier' });
+const LicenseSchema = z.union([
+    SpdxLicenseSchema,
+    z.string().regex(/^LicenseRef-[A-Za-z0-9.-]+$/, {
+        message: 'license must be an SPDX expression or LicenseRef-* identifier'
+    })
+]);
+// Release Manifest v4 的 name 是技能归属的唯一权威来源（ADR-0032）：
+// `@scope/skill-name` 或无 scope 的 `skill-name`（解析为上传者个人命名空间）。
+const SKILL_IDENTITY_PATTERN = '^(@[a-z0-9-]+/)?[a-z0-9-]{1,64}$';
+export const SkillIdentitySchema = z.string().regex(new RegExp(SKILL_IDENTITY_PATTERN), {
+    message: 'name must be "@scope/skill-name" or a bare "skill-name" (personal namespace)'
+});
+// 显示名长度上限（ADR-0048）：trim 后按字符数计。
+export const DISPLAY_NAME_MAX_LENGTH = 128;
+// 显示名（ADR-0048）：纯展示短标题，可为中文与空格，不参与身份/授权。空串与
+// 全空白按「未设置」处理，trim 后长度上限 128。
+const DisplayNameSchema = z
+    .string({ message: 'displayName must be a string' })
+    .optional()
+    .transform((value) => {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+});
+export const ReleaseManifestSchema = z
+    .object({
+    schemaVersion: z.union([z.literal(3), z.literal(4)]),
+    name: SkillIdentitySchema,
+    version: SemVerSchema,
+    license: LicenseSchema,
+    displayName: DisplayNameSchema,
+    keywords: z.array(z.string().min(1)),
+    compatibility: z.object({
+        tools: z.array(z.string().min(1)).optional(),
+        languages: z.array(z.string().min(1)).optional()
+    }),
+    dependencies: z.record(z.string().regex(/^@[a-z0-9-]+\/[a-z0-9-]+$/), z.string().min(1))
+})
+    .strict()
+    .superRefine((data, ctx) => {
+    if (data.displayName === undefined)
+        return;
+    // 带 displayName 的清单必须是 v4（ADR-0048）：字段随 v4 引入，v3 保持
+    // 旧契约不承载新字段，避免旧 CLI 遇未知键时既报错又无版本信号。
+    if (data.schemaVersion === 3) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['displayName'],
+            message: 'displayName requires schemaVersion 4 (the field was added in Release Manifest v4)'
+        });
+    }
+    // 长度上限按 trim 后计算（去空白）。
+    if (data.displayName.length > DISPLAY_NAME_MAX_LENGTH) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['displayName'],
+            message: `displayName must be at most ${DISPLAY_NAME_MAX_LENGTH} characters after trimming`
+        });
+    }
+});
+// Release Manifest v4 的 name 即 Skill Identity（ADR-0032）：`@scope/skill-name`
+// 或裸 `skill-name`（消费端按上传者用户名补全为个人命名空间）。解析失败返回 null。
+export function parseSkillIdentity(name) {
+    const match = name.match(/^@([a-z0-9-]+)\/([a-z0-9-]{1,64})$/);
+    if (match) {
+        return { scope: match[1], shortName: match[2] };
+    }
+    if (/^[a-z0-9-]{1,64}$/.test(name)) {
+        return { scope: null, shortName: name };
+    }
+    return null;
+}
+// 显示名种子（ADR-0048）：init 生成 v4 清单时把机器短名转成标题
+// （markdown-master → Markdown Master）。运行时解析对外显示名不做此转换，
+// 只在此处生成可编辑的初始值。
+export function titleCaseDisplayName(name) {
+    const shortName = parseSkillIdentity(name)?.shortName ?? name;
+    return shortName
+        .split('-')
+        .filter((word) => word.length > 0)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+export function createMinimalReleaseManifest(name, license, displayName) {
+    return {
+        schemaVersion: 4,
+        name,
+        version: '0.1.0',
+        license,
+        ...(displayName ? { displayName } : {}),
+        keywords: [],
+        compatibility: {},
+        dependencies: {}
+    };
+}
+export function validateReleaseManifest(data) {
+    const result = ReleaseManifestSchema.safeParse(data);
+    if (result.success)
+        return { success: true, data: result.data };
+    const errors = result.error.issues.map((issue) => {
+        const field = issue.path.join('.') || 'release.json';
+        return `${field}: ${issue.message}`;
+    });
+    if (isPreVersionManifest(data)) {
+        errors.push('release.json: schemaVersion 1 is no longer supported; run `esl version <SemVer>` to record the version, then commit and push the source');
+    }
+    if (isV2Manifest(data)) {
+        errors.push('release.json: schemaVersion 2 is no longer supported; add the required "name" field ("@scope/skill-name" or a bare "skill-name") and set schemaVersion to 3 or 4');
+    }
+    return { success: false, errors };
+}
+function isPreVersionManifest(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        data.schemaVersion === 1);
+}
+function isV2Manifest(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        data.schemaVersion === 2);
+}
+export async function validateSkillSourceDirectory(directory) {
+    const resolved = path.resolve(directory);
+    const skillMdPath = path.join(resolved, 'SKILL.md');
+    const releaseManifestPath = path.join(resolved, 'release.json');
+    const errors = [];
+    let skillMd;
+    let releaseManifest;
+    try {
+        const validation = validateSkillMd(await fs.readFile(skillMdPath, 'utf8'));
+        if (validation.success)
+            skillMd = validation.data;
+        else
+            errors.push(...validation.errors);
+    }
+    catch {
+        errors.push('SKILL.md: file is required');
+    }
+    try {
+        const parsed = JSON.parse(await fs.readFile(releaseManifestPath, 'utf8'));
+        const validation = validateReleaseManifest(parsed);
+        if (validation.success)
+            releaseManifest = validation.data;
+        else
+            errors.push(...validation.errors);
+    }
+    catch {
+        errors.push('release.json: file is required and must contain valid JSON');
+    }
+    if (errors.length > 0 || !skillMd || !releaseManifest) {
+        return { success: false, errors };
+    }
+    return { success: true, data: { directory: resolved, skillMd, releaseManifest } };
+}

package/dist/vendor/core/schema/skill-json.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import type { ValidationResult } from './validation-result.js';
+export declare const SkillNameSchema: z.ZodString;
+export declare const SemVerSchema: z.ZodString;
+export declare const SkillJsonSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    author: z.ZodString;
+    license: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    compatibility: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        languages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        tools?: string[] | undefined;
+        languages?: string[] | undefined;
+    }, {
+        tools?: string[] | undefined;
+        languages?: string[] | undefined;
+    }>>;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    repository: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    license?: string | undefined;
+    keywords?: string[] | undefined;
+    compatibility?: {
+        tools?: string[] | undefined;
+        languages?: string[] | undefined;
+    } | undefined;
+    dependencies?: Record<string, string> | undefined;
+    repository?: string | undefined;
+}, {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    license?: string | undefined;
+    keywords?: string[] | undefined;
+    compatibility?: {
+        tools?: string[] | undefined;
+        languages?: string[] | undefined;
+    } | undefined;
+    dependencies?: Record<string, string> | undefined;
+    repository?: string | undefined;
+}>;
+export type SkillJson = z.infer<typeof SkillJsonSchema>;
+export declare function validateSkillJson(data: unknown): ValidationResult<SkillJson>;
+export declare function parseSkillName(name: string): {
+    scope: string;
+    skillName: string;
+};
+export declare function createMinimalSkillManifest(input: {
+    name: string;
+    description: string;
+    author: string;
+}): SkillJson;

package/dist/vendor/core/schema/skill-json.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export const SkillNameSchema = z.string().regex(/^@[a-z0-9-]+\/[a-z0-9-]+$/, {
+    message: 'Skill name must follow @namespace/skill-name using lowercase letters, digits, and hyphens'
+});
+export const SemVerSchema = z.string().regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/, {
+    message: 'Version must be valid SemVer such as 1.0.0'
+});
+export const SkillJsonSchema = z.object({
+    name: SkillNameSchema,
+    version: SemVerSchema,
+    description: z.string().min(1).max(1024),
+    author: z.string().min(1),
+    license: z.string().optional(),
+    keywords: z.array(z.string().min(1)).optional(),
+    compatibility: z
+        .object({
+        tools: z.array(z.string().min(1)).optional(),
+        languages: z.array(z.string().min(1)).optional()
+    })
+        .optional(),
+    dependencies: z.record(SkillNameSchema, z.string().min(1)).optional(),
+    repository: z.string().min(1).optional()
+});
+export function validateSkillJson(data) {
+    const result = SkillJsonSchema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return {
+        success: false,
+        errors: result.error.issues.map((issue) => {
+            const path = issue.path.join('.') || 'skill.json';
+            return `${path}: ${issue.message}`;
+        })
+    };
+}
+export function parseSkillName(name) {
+    const result = SkillNameSchema.safeParse(name);
+    if (!result.success) {
+        throw new Error('Skill name must follow @namespace/skill-name using lowercase letters, digits, and hyphens');
+    }
+    const [scope, skillName] = name.slice(1).split('/');
+    return { scope, skillName };
+}
+export function createMinimalSkillManifest(input) {
+    return { name: input.name, version: '0.1.0', description: input.description, author: input.author, keywords: [] };
+}

package/dist/vendor/core/schema/validation-result.d.ts

@@ -0,0 +1,7 @@
+export type ValidationResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    errors: string[];
+};

package/dist/vendor/core/schema/validation-result.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/core/skill/builtin-package.d.ts

@@ -0,0 +1,32 @@
+export interface BuiltinPackageManifestEntry {
+    name: string;
+    version: string;
+    checksum: string;
+    shortName: string;
+}
+export interface BuiltinPackageManifest {
+    version: 1;
+    packages: Record<string, BuiltinPackageManifestEntry>;
+}
+export interface BuiltinPackage {
+    name: string;
+    shortName: string;
+    version: string;
+    checksum: string;
+    directory: string;
+}
+export interface BuildBuiltinPackageOptions {
+    sourceDir: string;
+    outputRoot: string;
+    identity: string;
+    cliVersion: string;
+    author?: string;
+}
+export declare const BUILTIN_SCOPE = "builtin";
+export declare const BUILTIN_IDENTITY = "@builtin/esl-operator";
+export declare const BUILTIN_SPECIFIER_PREFIX = "builtin:";
+export declare function isBuiltinIdentity(name: string): boolean;
+export declare function buildBuiltinPackage(options: BuildBuiltinPackageOptions): Promise<BuiltinPackageManifestEntry>;
+export declare function loadBuiltinPackage(builtinRoot: string, name: string): Promise<BuiltinPackage | null>;
+export declare function loadBuiltinPackageOrThrow(builtinRoot: string, name: string): Promise<BuiltinPackage>;
+export declare function computePackageChecksum(directory: string): Promise<string>;

package/dist/vendor/core/skill/builtin-package.js

@@ -0,0 +1,143 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { parseSkillName, SemVerSchema } from '../schema/skill-json.js';
+import { validateSkillMd } from './skill-md.js';
+const BUILTIN_MANIFEST = 'builtin-packages.json';
+export const BUILTIN_SCOPE = 'builtin';
+export const BUILTIN_IDENTITY = '@builtin/esl-operator';
+export const BUILTIN_SPECIFIER_PREFIX = 'builtin:';
+export function isBuiltinIdentity(name) {
+    try {
+        return parseSkillName(name).scope === BUILTIN_SCOPE;
+    }
+    catch {
+        return false;
+    }
+}
+export async function buildBuiltinPackage(options) {
+    const { scope, skillName } = parseSkillName(options.identity);
+    if (scope !== 'builtin') {
+        throw new Error(`Built-in skill identity must use the builtin scope: ${options.identity}`);
+    }
+    if (!SemVerSchema.safeParse(options.cliVersion).success) {
+        throw new Error(`Built-in skill version must be a valid SemVer matching @foxian/esl: ${options.cliVersion}`);
+    }
+    const skillMdContent = await fs.readFile(path.join(options.sourceDir, 'SKILL.md'), 'utf8');
+    const skillMdValidation = validateSkillMd(skillMdContent);
+    if (!skillMdValidation.success) {
+        throw new Error(`Invalid built-in SKILL.md: ${skillMdValidation.errors.join(', ')}`);
+    }
+    if (skillMdValidation.data.name !== skillName) {
+        throw new Error(`SKILL.md name "${skillMdValidation.data.name}" must match built-in short name "${skillName}"`);
+    }
+    const packageDir = path.join(options.outputRoot, skillName);
+    await fs.rm(packageDir, { recursive: true, force: true });
+    await fs.mkdir(packageDir, { recursive: true });
+    const skillJson = {
+        name: options.identity,
+        version: options.cliVersion,
+        description: skillMdValidation.data.description,
+        author: options.author ?? '@foxian/esl',
+        keywords: []
+    };
+    await fs.writeFile(path.join(packageDir, 'skill.json'), `${JSON.stringify(skillJson, null, 2)}\n`, 'utf8');
+    await copySourceFiles(options.sourceDir, packageDir);
+    const checksum = await computePackageChecksum(packageDir);
+    const manifest = await loadManifest(options.outputRoot);
+    manifest.packages[options.identity] = {
+        name: options.identity,
+        version: options.cliVersion,
+        checksum,
+        shortName: skillName
+    };
+    await saveManifest(options.outputRoot, manifest);
+    return {
+        name: options.identity,
+        version: options.cliVersion,
+        checksum,
+        shortName: skillName
+    };
+}
+export async function loadBuiltinPackage(builtinRoot, name) {
+    const manifest = await loadManifest(builtinRoot);
+    const entry = manifest.packages[name];
+    if (!entry) {
+        return null;
+    }
+    const directory = path.join(builtinRoot, entry.shortName);
+    const actualChecksum = await computePackageChecksum(directory);
+    if (actualChecksum !== entry.checksum) {
+        throw new Error(`Built-in skill package checksum does not match: expected ${entry.checksum}, got ${actualChecksum}`);
+    }
+    return {
+        name: entry.name,
+        shortName: entry.shortName,
+        version: entry.version,
+        checksum: entry.checksum,
+        directory
+    };
+}
+export async function loadBuiltinPackageOrThrow(builtinRoot, name) {
+    const builtin = await loadBuiltinPackage(builtinRoot, name);
+    if (!builtin) {
+        throw new Error(`Unknown built-in skill: ${name}`);
+    }
+    return builtin;
+}
+async function loadManifest(builtinRoot) {
+    try {
+        const raw = await fs.readFile(path.join(builtinRoot, BUILTIN_MANIFEST), 'utf8');
+        const parsed = JSON.parse(raw);
+        return { version: 1, packages: parsed.packages ?? {} };
+    }
+    catch {
+        return { version: 1, packages: {} };
+    }
+}
+async function saveManifest(builtinRoot, manifest) {
+    await fs.mkdir(builtinRoot, { recursive: true });
+    await fs.writeFile(path.join(builtinRoot, BUILTIN_MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+}
+async function copySourceFiles(sourceDir, packageDir) {
+    const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name === '.git') {
+            continue;
+        }
+        const sourcePath = path.join(sourceDir, entry.name);
+        const targetPath = path.join(packageDir, entry.name);
+        if (entry.isDirectory()) {
+            await fs.cp(sourcePath, targetPath, { recursive: true });
+        }
+        else {
+            await fs.copyFile(sourcePath, targetPath);
+        }
+    }
+}
+export async function computePackageChecksum(directory) {
+    const files = [];
+    async function walk(current, rel) {
+        const entries = await fs.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryRel = rel ? `${rel}/${entry.name}` : entry.name;
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath, entryRel);
+            }
+            else {
+                files.push(entryRel);
+            }
+        }
+    }
+    await walk(directory, '');
+    files.sort();
+    const hash = crypto.createHash('sha256');
+    for (const file of files) {
+        const content = await fs.readFile(path.join(directory, file));
+        hash.update(file);
+        hash.update('\0');
+        hash.update(content);
+    }
+    return `sha256-${hash.digest('hex')}`;
+}

package/dist/vendor/core/skill/directory-validator.d.ts

@@ -0,0 +1,9 @@
+import { type SkillJson } from '../schema/skill-json.js';
+import type { ValidationResult } from '../schema/validation-result.js';
+import { type SkillMdMetadata } from './skill-md.js';
+export interface SkillDirectory {
+    directory: string;
+    skillJson: SkillJson;
+    skillMd: SkillMdMetadata;
+}
+export declare function validateSkillDirectory(directory: string): Promise<ValidationResult<SkillDirectory>>;

package/dist/vendor/core/skill/directory-validator.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parseSkillName, validateSkillJson } from '../schema/skill-json.js';
+import { validateSkillMd } from './skill-md.js';
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function validateSkillDirectory(directory) {
+    const errors = [];
+    const skillJsonPath = path.join(directory, 'skill.json');
+    const skillMdPath = path.join(directory, 'SKILL.md');
+    if (!(await exists(skillJsonPath))) {
+        errors.push('skill.json: file is required');
+    }
+    if (!(await exists(skillMdPath))) {
+        errors.push('SKILL.md: file is required');
+    }
+    if (await exists(path.join(directory, 'resources'))) {
+        errors.push('resources/: deprecated; use assets/ for runtime assets');
+    }
+    let skillJson;
+    let skillMd;
+    if (await exists(skillJsonPath)) {
+        try {
+            const raw = await fs.readFile(skillJsonPath, 'utf8');
+            const validation = validateSkillJson(JSON.parse(raw));
+            if (validation.success) {
+                skillJson = validation.data;
+            }
+            else {
+                errors.push(...validation.errors);
+            }
+        }
+        catch (error) {
+            errors.push(`skill.json: ${error.message}`);
+        }
+    }
+    if (await exists(skillMdPath)) {
+        try {
+            const validation = validateSkillMd(await fs.readFile(skillMdPath, 'utf8'));
+            if (validation.success) {
+                skillMd = validation.data;
+            }
+            else {
+                errors.push(...validation.errors);
+            }
+        }
+        catch (error) {
+            errors.push(`SKILL.md: ${error.message}`);
+        }
+    }
+    if (skillJson && skillMd) {
+        const { scope, skillName } = parseSkillName(skillJson.name);
+        if (skillMd.name !== skillName) {
+            errors.push(`SKILL.md name must match skill.json name suffix "${skillName}"`);
+        }
+        const directoryName = path.basename(path.resolve(directory));
+        if (skillMd.name !== directoryName && `${scope}_${skillName}` !== directoryName) {
+            errors.push(`SKILL.md name must match directory name "${directoryName}"`);
+        }
+    }
+    if (errors.length > 0 || !skillJson || !skillMd) {
+        return { success: false, errors };
+    }
+    return { success: true, data: { directory, skillJson, skillMd } };
+}

package/dist/vendor/core/skill/import-skill.d.ts

@@ -0,0 +1,10 @@
+export interface PrepareSkillImportOptions {
+    namespace?: string;
+    author?: string;
+}
+export interface PrepareSkillImportResult {
+    directory: string;
+    skillName: string;
+    createdSkillJson: boolean;
+}
+export declare function prepareSkillImport(directory: string, options?: PrepareSkillImportOptions): Promise<PrepareSkillImportResult>;

package/dist/vendor/core/skill/import-skill.js

@@ -0,0 +1,68 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parseSkillName, validateSkillJson } from '../schema/skill-json.js';
+import { validateSkillDirectory } from './directory-validator.js';
+import { validateSkillMd } from './skill-md.js';
+const NamespacePattern = /^[a-z0-9-]+$/;
+async function fileExists(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function readExistingSkillJson(skillJsonPath) {
+    const raw = await fs.readFile(skillJsonPath, 'utf8');
+    const validation = validateSkillJson(JSON.parse(raw));
+    if (!validation.success) {
+        throw new Error(validation.errors.join(', '));
+    }
+    return validation.data;
+}
+export async function prepareSkillImport(directory, options = {}) {
+    const resolved = path.resolve(directory);
+    const stat = await fs.stat(resolved).catch(() => null);
+    if (!stat?.isDirectory()) {
+        throw new Error(`${resolved} is not a directory`);
+    }
+    const skillMdPath = path.join(resolved, 'SKILL.md');
+    const skillMdValidation = validateSkillMd(await fs.readFile(skillMdPath, 'utf8'));
+    if (!skillMdValidation.success) {
+        throw new Error(skillMdValidation.errors.join(', '));
+    }
+    const namespace = options.namespace ?? 'local';
+    if (!NamespacePattern.test(namespace)) {
+        throw new Error('Namespace must use lowercase letters, digits, and hyphens');
+    }
+    const skillName = `@${namespace}/${skillMdValidation.data.name}`;
+    parseSkillName(skillName);
+    const skillJsonPath = path.join(resolved, 'skill.json');
+    const createdSkillJson = !(await fileExists(skillJsonPath));
+    if (createdSkillJson) {
+        const skillJson = {
+            name: skillName,
+            version: '0.1.0',
+            description: skillMdValidation.data.description,
+            author: options.author ?? process.env.USER ?? process.env.USERNAME ?? 'anonymous',
+            keywords: []
+        };
+        await fs.writeFile(skillJsonPath, `${JSON.stringify(skillJson, null, 2)}\n`, 'utf8');
+    }
+    else {
+        const existing = await readExistingSkillJson(skillJsonPath);
+        if (existing.name !== skillName) {
+            throw new Error(`skill.json name "${existing.name}" must match import name "${skillName}"`);
+        }
+    }
+    const validation = await validateSkillDirectory(resolved);
+    if (!validation.success) {
+        throw new Error(`Invalid skill package at ${resolved}: ${validation.errors.join(', ')}`);
+    }
+    return {
+        directory: resolved,
+        skillName,
+        createdSkillJson
+    };
+}

package/dist/vendor/core/skill/published-package.d.ts

@@ -0,0 +1 @@
+export declare function preparePublishedSkillPackage(directory: string, identity: string): Promise<void>;

package/dist/vendor/core/skill/published-package.js

@@ -0,0 +1,9 @@
+import fs from 'node:fs/promises';
+import { parseSkillName } from '../schema/skill-json.js';
+export async function preparePublishedSkillPackage(directory, identity) {
+    const { scope, skillName } = parseSkillName(identity);
+    const skillMdPath = `${directory}/SKILL.md`;
+    const content = await fs.readFile(skillMdPath, 'utf8');
+    const updated = content.replace(/^(---\r?\n)([\s\S]*?)(\r?\n---)/, (_match, open, frontmatter, close) => `${open}${frontmatter.replace(/(^name:\s*)[^\r\n]+/m, `$1${scope}:${skillName}`)}${close}`);
+    await fs.writeFile(skillMdPath, updated, 'utf8');
+}

package/dist/vendor/core/skill/skill-md.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { ValidationResult } from '../schema/validation-result.js';
+declare const SkillMdMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+}, {
+    name: string;
+    description: string;
+}>;
+export type SkillMdMetadata = z.infer<typeof SkillMdMetadataSchema>;
+export declare function validateSkillMd(content: string): ValidationResult<SkillMdMetadata>;
+export {};