@foxian/esl 0.1.0

package/dist/vendor/core/link/tool-links.js

@@ -0,0 +1,376 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { loadInstallManifest, skillDirectoryName, skillSourceRelativeDir } from '../store/skill-store.js';
+export const SUPPORTED_TOOLS = [
+    'claude',
+    'codex',
+    'cursor',
+    'trae-intl',
+    'trae-cn',
+    'workbuddy',
+    'opencode',
+    'openclaw',
+    'hermes'
+];
+const TOOL_LINK_MANIFEST_FILE = '.esl-tools-manifest.json';
+export function isSupportedTool(value) {
+    return SUPPORTED_TOOLS.includes(value);
+}
+const TOOL_NAME_ALIASES = {
+    'claude-code': 'claude'
+};
+export function resolveToolName(value) {
+    const normalized = value.trim().toLowerCase();
+    return isSupportedTool(normalized) ? normalized : TOOL_NAME_ALIASES[normalized];
+}
+export function parseToolSelection(value) {
+    const raw = value.trim().toLowerCase();
+    if (raw === 'all') {
+        return [...SUPPORTED_TOOLS];
+    }
+    const tools = value
+        .split(',')
+        .map((tool) => tool.trim().toLowerCase())
+        .filter((tool) => tool.length > 0);
+    const resolved = tools.map((tool) => resolveToolName(tool));
+    for (const [index, tool] of resolved.entries()) {
+        if (tool === undefined) {
+            throw new Error(`Unknown tool: ${tools[index]}. Supported tools: ${SUPPORTED_TOOLS.join(', ')}`);
+        }
+    }
+    return resolved;
+}
+export function toolDirectory(tool, level, options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const homeDir = options.homeDir ?? os.homedir();
+    switch (tool) {
+        case 'claude':
+            return level === 'project'
+                ? path.join(projectRoot, '.claude', 'skills')
+                : path.join(homeDir, '.claude', 'skills');
+        case 'codex':
+            return level === 'project'
+                ? path.join(projectRoot, '.codex', 'skills')
+                : path.join(homeDir, '.codex', 'skills');
+        case 'cursor':
+            return level === 'project'
+                ? path.join(projectRoot, '.cursor', 'skills')
+                : path.join(homeDir, '.cursor', 'skills');
+        case 'trae-intl':
+            return level === 'project'
+                ? path.join(projectRoot, '.trae', 'skills')
+                : path.join(homeDir, '.trae', 'skills');
+        case 'trae-cn':
+            return level === 'project'
+                ? path.join(projectRoot, '.trae', 'skills')
+                : path.join(homeDir, '.trae-cn', 'skills');
+        case 'workbuddy':
+            return level === 'project'
+                ? path.join(projectRoot, '.workbuddy', 'skills')
+                : path.join(homeDir, '.workbuddy', 'skills');
+        case 'opencode':
+            return level === 'project'
+                ? path.join(projectRoot, '.opencode', 'skills')
+                : path.join(homeDir, '.config', 'opencode', 'skills');
+        case 'openclaw':
+            return level === 'project'
+                ? path.join(projectRoot, 'skills')
+                : path.join(homeDir, '.openclaw', 'skills');
+        case 'hermes':
+            return level === 'project'
+                ? path.join(projectRoot, '.hermes', 'skills')
+                : path.join(homeDir, '.hermes', 'skills');
+    }
+}
+export function toolLinkManifestPath(storeRoot) {
+    return path.join(storeRoot, TOOL_LINK_MANIFEST_FILE);
+}
+export function defaultToolLinkManifest() {
+    return { version: 1, links: [] };
+}
+export async function loadToolLinkManifest(storeRoot) {
+    try {
+        const raw = await fs.readFile(toolLinkManifestPath(storeRoot), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1 || !Array.isArray(parsed.links)) {
+            throw new Error('Invalid ESL tools manifest');
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return defaultToolLinkManifest();
+        }
+        throw error;
+    }
+}
+export async function saveToolLinkManifest(storeRoot, manifest) {
+    await fs.mkdir(storeRoot, { recursive: true });
+    await fs.writeFile(toolLinkManifestPath(storeRoot), `${JSON.stringify({ version: 1, links: manifest.links }, null, 2)}\n`, 'utf8');
+}
+async function lstatPath(target) {
+    try {
+        return await fs.lstat(target);
+    }
+    catch {
+        return null;
+    }
+}
+async function isLink(target) {
+    const stat = await lstatPath(target);
+    return stat?.isSymbolicLink() ?? false;
+}
+async function readLinkTarget(target) {
+    try {
+        return path.resolve(await fs.readlink(target));
+    }
+    catch {
+        return null;
+    }
+}
+async function directoryExists(target) {
+    try {
+        return (await fs.stat(target)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function createLink(sourceDir, targetDir) {
+    await fs.mkdir(path.dirname(targetDir), { recursive: true });
+    if (process.platform === 'win32') {
+        await fs.symlink(sourceDir, targetDir, 'junction');
+    }
+    else {
+        await fs.symlink(sourceDir, targetDir, 'dir');
+    }
+}
+function recordKey(record) {
+    return `${record.identity}\n${record.tool}\n${record.level}`;
+}
+export async function createToolLink(options) {
+    const { identity, tool, level, storeRoot, force = false } = options;
+    const sourceDir = path.resolve(storeRoot, skillSourceRelativeDir(identity));
+    const targetDir = path.resolve(toolDirectory(tool, level, options), skillDirectoryName(identity));
+    const manifest = await loadToolLinkManifest(storeRoot);
+    const existingRecord = manifest.links.find((record) => recordKey(record) === recordKey({ identity, tool, level }));
+    const targetStat = await lstatPath(targetDir);
+    if (targetStat) {
+        if (targetStat.isSymbolicLink()) {
+            const currentTarget = await readLinkTarget(targetDir);
+            if (currentTarget === sourceDir) {
+                if (existingRecord) {
+                    return { identity, tool, targetDir, status: 'existing' };
+                }
+                const managedByAnotherTool = manifest.links.some((record) => record.level === level &&
+                    targetKey(record.targetDir) === targetKey(targetDir) &&
+                    path.resolve(storeRoot, record.sourceDir) === sourceDir);
+                if (managedByAnotherTool) {
+                    manifest.links.push({
+                        identity,
+                        tool,
+                        level,
+                        sourceDir: path.relative(storeRoot, sourceDir),
+                        targetDir,
+                        createdAt: new Date().toISOString()
+                    });
+                    await saveToolLinkManifest(storeRoot, manifest);
+                    return { identity, tool, targetDir, status: 'existing' };
+                }
+                return {
+                    identity,
+                    tool,
+                    targetDir,
+                    status: 'conflict',
+                    error: 'target link is unmanaged; ESL did not create it'
+                };
+            }
+            if (force && existingRecord && path.resolve(existingRecord.targetDir) === targetDir) {
+                await fs.rm(targetDir, { force: true });
+            }
+            else {
+                return { identity, tool, targetDir, status: 'conflict' };
+            }
+        }
+        else {
+            return { identity, tool, targetDir, status: 'conflict' };
+        }
+    }
+    if (!await directoryExists(sourceDir)) {
+        return { identity, tool, targetDir, status: 'conflict' };
+    }
+    await createLink(sourceDir, targetDir);
+    const record = {
+        identity,
+        tool,
+        level,
+        sourceDir: path.relative(storeRoot, sourceDir),
+        targetDir,
+        createdAt: new Date().toISOString()
+    };
+    const nextLinks = manifest.links.filter((candidate) => recordKey(candidate) !== recordKey(record));
+    nextLinks.push(record);
+    await saveToolLinkManifest(storeRoot, { version: 1, links: nextLinks });
+    return { identity, tool, targetDir, status: 'created' };
+}
+export async function syncToolLinks(options) {
+    const manifest = await loadInstallManifest(options.storeRoot);
+    const results = [];
+    const identities = options.identities ?? Object.keys(manifest.skills);
+    for (const identity of identities) {
+        if (!manifest.skills[identity]) {
+            continue;
+        }
+        for (const tool of options.tools) {
+            try {
+                results.push(await createToolLink({
+                    identity,
+                    tool,
+                    level: options.level,
+                    storeRoot: options.storeRoot,
+                    projectRoot: options.projectRoot,
+                    homeDir: options.homeDir,
+                    force: options.force
+                }));
+            }
+            catch (error) {
+                results.push({
+                    identity,
+                    tool,
+                    targetDir: path.resolve(toolDirectory(tool, options.level, options), skillDirectoryName(identity)),
+                    status: 'failed',
+                    error: error.message
+                });
+            }
+        }
+    }
+    return results;
+}
+export async function removeToolLinks(options) {
+    const manifest = await loadToolLinkManifest(options.storeRoot);
+    const results = [];
+    const requestedTools = new Set(options.tools);
+    const remaining = [];
+    const requestedRecords = manifest.links.filter((record) => record.identity === options.identity &&
+        record.level === options.level &&
+        requestedTools.has(record.tool));
+    for (const record of manifest.links) {
+        if (!requestedRecords.includes(record)) {
+            remaining.push(record);
+            continue;
+        }
+        const targetDir = path.resolve(record.targetDir);
+        const expectedSourceDir = path.resolve(options.storeRoot, record.sourceDir);
+        const sharedReference = manifest.links.some((candidate) => !requestedRecords.includes(candidate) &&
+            candidate.level === record.level &&
+            targetKey(candidate.targetDir) === targetKey(record.targetDir));
+        if (await isLink(targetDir)) {
+            const currentTarget = await readLinkTarget(targetDir);
+            if (currentTarget === expectedSourceDir) {
+                if (!sharedReference) {
+                    await fs.rm(targetDir, { force: true });
+                }
+                results.push({ identity: record.identity, tool: record.tool, targetDir, status: 'removed' });
+                continue;
+            }
+            results.push({ identity: record.identity, tool: record.tool, targetDir, status: 'conflict' });
+            remaining.push(record);
+            continue;
+        }
+        if (await directoryExists(targetDir)) {
+            results.push({ identity: record.identity, tool: record.tool, targetDir, status: 'conflict' });
+            remaining.push(record);
+            continue;
+        }
+        results.push({ identity: record.identity, tool: record.tool, targetDir, status: 'missing' });
+    }
+    await saveToolLinkManifest(options.storeRoot, { version: 1, links: remaining });
+    return results;
+}
+export async function listToolLinks(options) {
+    const [installManifest, toolManifest] = await Promise.all([
+        loadInstallManifest(options.storeRoot),
+        loadToolLinkManifest(options.storeRoot)
+    ]);
+    const entries = [];
+    const manifestRecords = toolManifest.links.filter((record) => record.level === options.level);
+    const recordTargets = new Set(manifestRecords.map((record) => targetKey(record.targetDir)));
+    for (const record of manifestRecords) {
+        const targetDir = path.resolve(record.targetDir);
+        const expectedSourceDir = path.resolve(options.storeRoot, record.sourceDir);
+        const stat = await lstatPath(targetDir);
+        let status;
+        if (!stat) {
+            status = 'broken';
+        }
+        else if (!stat.isSymbolicLink()) {
+            status = 'conflict';
+        }
+        else {
+            const linkTarget = await readLinkTarget(targetDir);
+            if (linkTarget === expectedSourceDir && await directoryExists(expectedSourceDir)) {
+                status = 'linked';
+            }
+            else if (linkTarget && !await directoryExists(linkTarget)) {
+                status = 'broken';
+            }
+            else {
+                status = 'conflict';
+            }
+        }
+        entries.push({
+            tool: record.tool,
+            identity: record.identity,
+            level: options.level,
+            status,
+            managed: true,
+            sourceDir: expectedSourceDir,
+            targetDir
+        });
+    }
+    for (const tool of SUPPORTED_TOOLS) {
+        const directory = toolDirectory(tool, options.level, options);
+        let dirents;
+        try {
+            dirents = await fs.readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const dirent of dirents) {
+            const targetDir = path.join(directory, dirent.name);
+            if (recordTargets.has(targetKey(targetDir))) {
+                continue;
+            }
+            const stat = await lstatPath(targetDir);
+            entries.push({
+                tool,
+                identity: dirent.name,
+                level: options.level,
+                status: stat?.isDirectory() || stat?.isSymbolicLink() ? 'unmanaged' : 'conflict',
+                managed: false,
+                sourceDir: '',
+                targetDir
+            });
+        }
+    }
+    const recordedIdentities = new Set(manifestRecords.map((record) => record.identity));
+    for (const identity of Object.keys(installManifest.skills)) {
+        if (!recordedIdentities.has(identity)) {
+            entries.push({
+                tool: 'source',
+                identity,
+                level: options.level,
+                status: 'source-only',
+                managed: true,
+                sourceDir: path.resolve(options.storeRoot, installManifest.skills[identity].sourceDir)
+            });
+        }
+    }
+    return entries;
+}
+function targetKey(targetDir) {
+    const resolved = path.resolve(targetDir);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}

package/dist/vendor/core/org/account-policy.d.ts

@@ -0,0 +1,8 @@
+import type { ValidationResult } from '../schema/validation-result.js';
+export declare const RESERVED_SCOPE_NAMES: ReadonlySet<string>;
+export declare const DEFAULT_PASSWORD_MIN_LENGTH = 8;
+export declare function validatePassword(password: string, minimumLength?: number): ValidationResult<string>;
+export declare function validateMemberUsername(username: string): ValidationResult<string>;
+export declare function normalizeSkillUserEmail(email: string): string;
+export declare function validateSkillUserEmail(email: string): ValidationResult<string>;
+export declare function giteaUserEmail(giteaUsername: string): string;

package/dist/vendor/core/org/account-policy.js

@@ -0,0 +1,57 @@
+const ACCOUNT_NAME_PATTERN = /^[a-z0-9-]+$/;
+const SKILL_USER_EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+// 扁平命名池的保留名（ADR-0032）：用户名与组织名共用同一约束，
+// 保证保留 scope 与系统路径永远可用。
+export const RESERVED_SCOPE_NAMES = new Set([
+    'local',
+    'builtin',
+    'admin',
+    'api',
+    'git',
+    'system'
+]);
+export const DEFAULT_PASSWORD_MIN_LENGTH = 8;
+export function validatePassword(password, minimumLength = DEFAULT_PASSWORD_MIN_LENGTH) {
+    if (password.length < minimumLength) {
+        return {
+            success: false,
+            errors: [`password must be at least ${minimumLength} characters`]
+        };
+    }
+    return { success: true, data: password };
+}
+export function validateMemberUsername(username) {
+    const errors = [];
+    if (username.length < 2 || username.length > 39) {
+        errors.push('username must be 2-39 characters');
+    }
+    if (!ACCOUNT_NAME_PATTERN.test(username)) {
+        errors.push('username may only contain lowercase letters, digits, and hyphens');
+    }
+    if (username.startsWith('-') || username.endsWith('-')) {
+        errors.push('username must not start or end with a hyphen');
+    }
+    if (RESERVED_SCOPE_NAMES.has(username)) {
+        errors.push('username is reserved');
+    }
+    return errors.length > 0 ? { success: false, errors } : { success: true, data: username };
+}
+export function normalizeSkillUserEmail(email) {
+    return email.trim().toLowerCase();
+}
+export function validateSkillUserEmail(email) {
+    const normalized = normalizeSkillUserEmail(email);
+    const errors = [];
+    if (!SKILL_USER_EMAIL_PATTERN.test(normalized)) {
+        errors.push('email must be a valid address');
+    }
+    if (normalized.endsWith('@local.esl')) {
+        errors.push('email domain is reserved');
+    }
+    return errors.length > 0 ? { success: false, errors } : { success: true, data: normalized };
+}
+// Git Backend 用户账号的 email 约定(用户创建流程统一使用该格式):以该 email
+// 作为 commit author 时,Git Backend 可通过 email 把提交匹配到对应账号。
+export function giteaUserEmail(giteaUsername) {
+    return `${giteaUsername}@local.esl`;
+}

package/dist/vendor/core/org/org-name.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationResult } from '../schema/validation-result.js';
+export declare function validateOrgName(name: string): ValidationResult<string>;

package/dist/vendor/core/org/org-name.js

@@ -0,0 +1,22 @@
+import { RESERVED_SCOPE_NAMES } from './account-policy.js';
+const ORG_NAME_PATTERN = /^[a-z0-9-]+$/;
+export function validateOrgName(name) {
+    const errors = [];
+    if (name.length < 2 || name.length > 39) {
+        errors.push('organization name must be 2-39 characters');
+        return { success: false, errors };
+    }
+    if (!ORG_NAME_PATTERN.test(name)) {
+        errors.push('organization name may only contain lowercase letters, digits, and hyphens');
+    }
+    if (name.startsWith('-') || name.endsWith('-')) {
+        errors.push('organization name must not start or end with a hyphen');
+    }
+    if (RESERVED_SCOPE_NAMES.has(name)) {
+        errors.push('organization name is reserved');
+    }
+    if (errors.length > 0) {
+        return { success: false, errors };
+    }
+    return { success: true, data: name };
+}

package/dist/vendor/core/org/standing-teams.d.ts

@@ -0,0 +1,10 @@
+export declare const STANDING_TEAM_NAMES: readonly string[];
+export declare function isStandingTeam(teamName: string): boolean;
+export declare const SHARE_TIER_TEAM_NAMES: {
+    readonly read: "all-readers";
+    readonly write: "all-writers";
+    readonly manage: "all-managers";
+};
+export type OrgIdentity = 'ordinary' | 'managing' | 'owner';
+export declare const AUTO_JOIN_TEAM_NAMES: readonly string[];
+export declare const MANAGING_TEAM_NAME = "org-managers";

package/dist/vendor/core/org/standing-teams.js

@@ -0,0 +1,27 @@
+// 常设团队（ADR-0032）：只读 / 读写 / 技能管理三个团队随成员进出组织自动增删，
+// 不可删除、不可改名；管理员团队就是 Git Backend 原生的 Owners。
+// 这里是团队标识名的单一来源——服务端与前端都不再各写一份。
+export const STANDING_TEAM_NAMES = [
+    'all-readers',
+    'all-writers',
+    'all-managers',
+    'org-managers'
+];
+export function isStandingTeam(teamName) {
+    return STANDING_TEAM_NAMES.includes(teamName);
+}
+// 授权档位 → 常设团队标识名（share_all_* 动作的落点）
+export const SHARE_TIER_TEAM_NAMES = {
+    read: 'all-readers',
+    write: 'all-writers',
+    manage: 'all-managers'
+};
+// 成员加入组织时**自动**加入的三个技能授权团队。管理成员身份团队 org-managers
+// 不在其中，必须由所有者成员通过身份变更授予。
+export const AUTO_JOIN_TEAM_NAMES = [
+    'all-readers',
+    'all-writers',
+    'all-managers'
+];
+// 承载管理成员身份的专用常设团队。技能共享级别 manage 的落点仍是 all-managers。
+export const MANAGING_TEAM_NAME = 'org-managers';

package/dist/vendor/core/schema/compatibility.d.ts

@@ -0,0 +1,17 @@
+import { execFile } from 'node:child_process';
+declare const execFileAsync: typeof execFile.__promisify__;
+export interface CompatibilityRequirements {
+    tools?: string[];
+    languages?: string[];
+}
+export interface CompatibilityResult {
+    compatible: boolean;
+    missingTools: string[];
+    unsupportedLanguages: string[];
+}
+export declare function evaluateCompatibility(requirements: CompatibilityRequirements, options?: {
+    execFileAsync?: typeof execFileAsync;
+    platform?: string;
+    nodeVersion?: string;
+}): Promise<CompatibilityResult>;
+export {};

package/dist/vendor/core/schema/compatibility.js

@@ -0,0 +1,45 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export async function evaluateCompatibility(requirements, options = {}) {
+    const runner = options.execFileAsync ?? execFileAsync;
+    const missingTools = [];
+    for (const tool of requirements.tools ?? []) {
+        try {
+            await runner(process.platform === 'win32' ? 'where' : 'which', [tool]);
+        }
+        catch {
+            missingTools.push(tool);
+        }
+    }
+    const platform = options.platform ?? process.platform;
+    const supportedLanguages = new Set(['node', 'nodejs', 'javascript', 'typescript']);
+    if (platform === 'win32')
+        supportedLanguages.add('powershell');
+    const unsupportedLanguages = [];
+    for (const language of requirements.languages ?? []) {
+        const normalized = language.toLowerCase();
+        if (supportedLanguages.has(normalized))
+            continue;
+        if (normalized === 'python') {
+            let found = false;
+            for (const candidate of ['python', 'python3']) {
+                try {
+                    await runner(process.platform === 'win32' ? 'where' : 'which', [candidate]);
+                    found = true;
+                    break;
+                }
+                catch {
+                }
+            }
+            if (found)
+                continue;
+        }
+        unsupportedLanguages.push(language);
+    }
+    return {
+        compatible: missingTools.length === 0 && unsupportedLanguages.length === 0,
+        missingTools,
+        unsupportedLanguages
+    };
+}

package/dist/vendor/core/schema/release-manifest.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import type { ValidationResult } from './validation-result.js';
+import { type SkillMdMetadata } from '../skill/skill-md.js';
+export declare const SkillIdentitySchema: z.ZodString;
+export declare const DISPLAY_NAME_MAX_LENGTH = 128;
+export declare const ReleaseManifestSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodUnion<[z.ZodLiteral<3>, z.ZodLiteral<4>]>;
+    name: z.ZodString;
+    version: z.ZodString;
+    license: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    displayName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    keywords: z.ZodArray<z.ZodString, "many">;
+    compatibility: 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.ZodRecord<z.ZodString, z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    license: string;
+    keywords: string[];
+    compatibility: {
+        tools?: string[] | undefined;
+        languages?: string[] | undefined;
+    };
+    dependencies: Record<string, string>;
+    schemaVersion: 3 | 4;
+    displayName?: string | undefined;
+}, {
+    name: string;
+    version: string;
+    license: string;
+    keywords: string[];
+    compatibility: {
+        tools?: string[] | undefined;
+        languages?: string[] | undefined;
+    };
+    dependencies: Record<string, string>;
+    schemaVersion: 3 | 4;
+    displayName?: string | undefined;
+}>, {
+    name: string;
+    version: string;
+    license: string;
+    keywords: string[];
+    compatibility: {
+        tools?: string[] | undefined;
+        languages?: string[] | undefined;
+    };
+    dependencies: Record<string, string>;
+    schemaVersion: 3 | 4;
+    displayName?: string | undefined;
+}, {
+    name: string;
+    version: string;
+    license: string;
+    keywords: string[];
+    compatibility: {
+        tools?: string[] | undefined;
+        languages?: string[] | undefined;
+    };
+    dependencies: Record<string, string>;
+    schemaVersion: 3 | 4;
+    displayName?: string | undefined;
+}>;
+export type ReleaseManifest = z.infer<typeof ReleaseManifestSchema>;
+export interface SkillIdentity {
+    /** 持有命名空间的组织名；null 表示上传者个人命名空间（@用户名）。 */
+    scope: string | null;
+    shortName: string;
+}
+export declare function parseSkillIdentity(name: string): SkillIdentity | null;
+export declare function titleCaseDisplayName(name: string): string;
+export declare function createMinimalReleaseManifest(name: string, license: string, displayName?: string): ReleaseManifest;
+export declare function validateReleaseManifest(data: unknown): ValidationResult<ReleaseManifest>;
+export interface SkillSourceDirectory {
+    directory: string;
+    skillMd: SkillMdMetadata;
+    releaseManifest: ReleaseManifest;
+}
+export declare function validateSkillSourceDirectory(directory: string): Promise<ValidationResult<SkillSourceDirectory>>;