@foxian/esl 0.1.0

package/dist/commands/version.js

@@ -0,0 +1,147 @@
+import { isBuiltinIdentity, validateReleaseManifest } from '../vendor/core/index.js';
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import semver from 'semver';
+const execFileAsync = promisify(execFile);
+const EXPLICIT_SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+function isBump(input) {
+    return input === 'major' || input === 'minor' || input === 'patch';
+}
+export function isValidExplicitVersion(input) {
+    return EXPLICIT_SEMVER_PATTERN.test(input);
+}
+export function nextVersion(current, bump) {
+    const next = semver.inc(current, bump);
+    if (!next) {
+        throw new Error(`Cannot bump invalid version: ${current}`);
+    }
+    return next;
+}
+async function isInsideGitRepo(dir) {
+    try {
+        await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: dir });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasCleanWorkingTree(dir) {
+    const { stdout } = await execFileAsync('git', ['status', '--porcelain'], { cwd: dir });
+    return stdout.trim().length === 0;
+}
+async function readManifest(dir) {
+    const manifestPath = path.join(dir, 'release.json');
+    let raw;
+    try {
+        raw = await fs.readFile(manifestPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const result = validateReleaseManifest(parsed);
+    if (result.success)
+        return { valid: true, data: result.data };
+    const isPreVersion = typeof parsed === 'object' &&
+        parsed !== null &&
+        parsed.schemaVersion === 1;
+    return { valid: false, isPreVersion, errors: result.errors };
+}
+async function readSkillJsonName(dir) {
+    try {
+        const raw = await fs.readFile(path.join(dir, 'skill.json'), 'utf8');
+        const data = JSON.parse(raw);
+        return data.name ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeVersion(dir, version) {
+    const manifestPath = path.join(dir, 'release.json');
+    const raw = await fs.readFile(manifestPath, 'utf8');
+    const data = JSON.parse(raw);
+    // 保留现有 v3/v4 版本；仅把 schemaVersion 1（版本跟踪前）升级到 v4（ADR-0048）。
+    const manifestVersion = typeof data.schemaVersion === 'number' ? data.schemaVersion : 1;
+    data.schemaVersion = manifestVersion >= 3 ? manifestVersion : 4;
+    data.version = version;
+    await fs.writeFile(manifestPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+async function commitAndTag(dir, version) {
+    const tag = `v${version}`;
+    await execFileAsync('git', ['add', 'release.json'], { cwd: dir });
+    const staged = (await execFileAsync('git', ['diff', '--cached', '--name-only'], { cwd: dir })).stdout.trim();
+    // Tagging the version the source already carries (the first release, where
+    // `init` seeded it) has nothing to commit — the tag is the whole point.
+    if (staged) {
+        await execFileAsync('git', ['commit', '-m', `chore: bump version to ${version}`], { cwd: dir });
+    }
+    await execFileAsync('git', ['tag', '-a', tag, '-m', `Release ${version}`], { cwd: dir });
+}
+async function readVersionInspection(directory) {
+    // Built-in identity check first — highest-priority rejection, regardless of directory shape
+    const skillName = await readSkillJsonName(directory);
+    if (skillName && isBuiltinIdentity(skillName)) {
+        throw new Error('Built-in skills cannot be versioned; their version is pinned to the ESL CLI version.');
+    }
+    // Check git — without a repo, we can't commit/tag
+    if (!(await isInsideGitRepo(directory))) {
+        throw new Error('This directory is not a git repository. Run `git init` and commit the skill source before using `esl version`.');
+    }
+    const manifestResult = await readManifest(directory);
+    // No release.json at all — this is not a source-form skill
+    if (manifestResult === null) {
+        throw new Error('No release.json found. `esl version` operates on a source-form skill directory (SKILL.md + release.json).');
+    }
+    if (!manifestResult.valid && manifestResult.isPreVersion) {
+        return { currentVersion: null, isPreVersion: true };
+    }
+    if (!manifestResult.valid) {
+        throw new Error(`Invalid release.json: ${manifestResult.errors.join(', ')}`);
+    }
+    return { currentVersion: manifestResult.data.version, isPreVersion: false };
+}
+async function assertCleanWorkingTree(directory) {
+    if (!(await hasCleanWorkingTree(directory))) {
+        throw new Error('Working tree is not clean. Commit or stash your changes before bumping the version so the version commit contains only the manifest change.');
+    }
+}
+export async function inspectVersion(directory) {
+    const inspection = await readVersionInspection(directory);
+    await assertCleanWorkingTree(directory);
+    return inspection;
+}
+export async function executeVersion(input, options = {}) {
+    const directory = options.cwd ?? process.cwd();
+    const inspection = await readVersionInspection(directory);
+    let newVersion;
+    if (isBump(input)) {
+        if (inspection.isPreVersion) {
+            throw new Error('This release manifest is from before version tracking (schemaVersion 1). Run `esl version <SemVer>` with an explicit version number to initialize versioning and upgrade the manifest to schemaVersion 4.');
+        }
+        if (!inspection.currentVersion) {
+            throw new Error('Cannot bump: no current version found in release.json.');
+        }
+        newVersion = nextVersion(inspection.currentVersion, input);
+    }
+    else {
+        // explicit SemVer — validate syntax
+        if (!isValidExplicitVersion(input)) {
+            throw new Error(`Invalid version: ${input}. Version must be valid SemVer (e.g. 1.2.3).`);
+        }
+        newVersion = input;
+    }
+    await assertCleanWorkingTree(directory);
+    await writeVersion(directory, newVersion);
+    await commitAndTag(directory, newVersion);
+    return newVersion;
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,14 @@
+import { type LocalStoreOptions, type OrganizationMembership } from '@esl/core';
+export interface WhoamiResult {
+    loggedIn: boolean;
+    username: string | null;
+    organizations: OrganizationMembership[] | null;
+    /** 旧版（<org>_<username> 时代）配置残留：需要重新登录 */
+    legacyIdentity: boolean;
+    server: string | null;
+    loginAt: string | null;
+    expiresAt: string | null;
+    expired: boolean;
+}
+export declare function executeWhoami(options?: LocalStoreOptions): Promise<WhoamiResult>;
+export declare function formatWhoami(result: WhoamiResult): string;

package/dist/commands/whoami.js

@@ -0,0 +1,54 @@
+import { loadConfig, loadCredentials } from '../vendor/core/index.js';
+import { isLoginFresh, resolveLoginTtlMs } from './network-options.js';
+export async function executeWhoami(options = {}) {
+    const config = await loadConfig({ homeDir: options.homeDir });
+    const credentials = await loadCredentials({ homeDir: options.homeDir });
+    const token = credentials.token;
+    const loginAt = credentials.loginAt;
+    const loginAtMs = loginAt ? Date.parse(loginAt) : NaN;
+    const expired = !isLoginFresh(loginAt);
+    return {
+        loggedIn: Boolean(token),
+        username: config.username ?? null,
+        organizations: config.organizations ?? null,
+        legacyIdentity: config.legacyIdentity ?? false,
+        server: config.server ?? null,
+        loginAt,
+        expiresAt: loginAt && !Number.isNaN(loginAtMs) ? new Date(loginAtMs + resolveLoginTtlMs()).toISOString() : null,
+        expired
+    };
+}
+export function formatWhoami(result) {
+    if (!result.loggedIn) {
+        return 'Not logged in. Run esl login to authenticate.';
+    }
+    const lines = [];
+    if (result.legacyIdentity) {
+        lines.push('Notice: this login predates the global identity model; run `esl login` again.');
+    }
+    if (result.username) {
+        lines.push(`Username: ${result.username}`);
+    }
+    if (result.organizations && result.organizations.length > 0) {
+        // 括号里是组织内身份（ADR-0038）：所有者成员 / 管理成员 / 普通成员，由常设团队
+        // 成员身份推导。组织内没有角色，这里标注的始终是团队身份。
+        const rendered = result.organizations
+            .map((membership) => `${membership.org} (${membership.identity})`)
+            .join(', ');
+        lines.push(`Organization memberships: ${rendered}`);
+    }
+    else if (result.organizations) {
+        lines.push('Organization memberships: none');
+    }
+    if (result.server) {
+        lines.push(`Server: ${result.server}`);
+    }
+    if (result.loginAt) {
+        lines.push(`Logged in at: ${result.loginAt}`);
+    }
+    if (result.expiresAt) {
+        lines.push(`Expires at: ${result.expiresAt}`);
+    }
+    lines.push(result.expired ? 'Status: expired (run esl login to re-authenticate)' : 'Status: active');
+    return lines.join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export declare const CLI_NAME = "esl";
+export * from './commands/init.js';
+export * from './commands/admin.js';
+export * from './commands/adapt.js';
+export * from './commands/source.js';
+export * from './commands/list.js';
+export * from './commands/use.js';
+export * from './commands/info.js';
+export * from './commands/install.js';
+export * from './commands/login.js';
+export * from './commands/publish.js';
+export * from './commands/deprecate.js';
+export * from './commands/release-delete.js';
+export * from './commands/rename.js';
+export * from './commands/repair-tag.js';
+export * from './commands/upload.js';
+export * from './commands/reset-source.js';
+export * from './commands/search.js';
+export * from './commands/update.js';
+export * from './commands/uninstall.js';
+export * from './commands/validate.js';
+export * from './commands/link.js';
+export * from './commands/unlink.js';
+export * from './commands/version.js';

package/dist/index.js

@@ -0,0 +1,24 @@
+export const CLI_NAME = 'esl';
+export * from './commands/init.js';
+export * from './commands/admin.js';
+export * from './commands/adapt.js';
+export * from './commands/source.js';
+export * from './commands/list.js';
+export * from './commands/use.js';
+export * from './commands/info.js';
+export * from './commands/install.js';
+export * from './commands/login.js';
+export * from './commands/publish.js';
+export * from './commands/deprecate.js';
+export * from './commands/release-delete.js';
+export * from './commands/rename.js';
+export * from './commands/repair-tag.js';
+export * from './commands/upload.js';
+export * from './commands/reset-source.js';
+export * from './commands/search.js';
+export * from './commands/update.js';
+export * from './commands/uninstall.js';
+export * from './commands/validate.js';
+export * from './commands/link.js';
+export * from './commands/unlink.js';
+export * from './commands/version.js';

package/dist/output.d.ts

@@ -0,0 +1 @@
+export declare function notify(message: string): void;

package/dist/output.js

@@ -0,0 +1,3 @@
+export function notify(message) {
+    process.stderr.write(`${message}\n`);
+}

package/dist/postinstall.d.ts

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

package/dist/postinstall.js

@@ -0,0 +1,8 @@
+import { syncGlobalBuiltinSkill } from './commands/sync-builtin.js';
+try {
+    await syncGlobalBuiltinSkill({});
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`esl: built-in skill global sync deferred: ${message}`);
+}

package/dist/prompt.d.ts

@@ -0,0 +1,9 @@
+export interface PromptStreams {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function readHidden(prompt: string, streams?: PromptStreams): Promise<string>;
+export declare function readText(prompt: string, streams?: PromptStreams): Promise<string>;
+export declare function confirm(question: string, streams?: PromptStreams): Promise<boolean>;
+export declare function isInteractive(): boolean;
+export declare function readStdinText(input?: NodeJS.ReadableStream): Promise<string>;

package/dist/prompt.js

@@ -0,0 +1,24 @@
+import { confirm as confirmPrompt, input, password } from '@inquirer/prompts';
+export function readHidden(prompt, streams = {}) {
+    return password({ message: prompt, mask: false, toggleMask: false }, streams);
+}
+export function readText(prompt, streams = {}) {
+    return input({ message: prompt }, streams);
+}
+export function confirm(question, streams = {}) {
+    return confirmPrompt({ message: question, default: false }, streams);
+}
+export function isInteractive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+export function readStdinText(input = process.stdin) {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        input.setEncoding('utf8');
+        input.on('data', (chunk) => {
+            data += chunk;
+        });
+        input.on('end', () => resolve(data));
+        input.on('error', reject);
+    });
+}

package/dist/vendor/core/adapt/adapt-engine.d.ts

@@ -0,0 +1,24 @@
+import { type LocalStoreOptions } from '../store/local-store.js';
+import { type ToolName } from '../link/tool-links.js';
+export interface AdaptResult {
+    tool: string;
+    skills: AdaptedSkillResult[];
+    adopted: AdaptedSkillResult[];
+    skipped: AdaptedSkillTargetResult[];
+    conflicts: AdaptedSkillTargetResult[];
+    failed: AdaptedSkillTargetResult[];
+}
+export interface AdaptedSkillResult {
+    identity: string;
+    directoryName: string;
+}
+export interface AdaptedSkillTargetResult extends AdaptedSkillResult {
+    targetDir: string;
+}
+interface AdaptOptions extends LocalStoreOptions {
+    tools?: ToolName[];
+    force?: boolean;
+}
+export declare function adaptProject(projectRoot: string, options?: AdaptOptions): Promise<AdaptResult[]>;
+export declare function adaptGlobal(options?: AdaptOptions): Promise<AdaptResult[]>;
+export {};

package/dist/vendor/core/adapt/adapt-engine.js

@@ -0,0 +1,99 @@
+import { loadConfig, resolveLocalStorePaths, resolveProjectStorePaths } from '../store/local-store.js';
+import { loadSkillsJson } from '../store/skills-json.js';
+import { isSupportedTool, SUPPORTED_TOOLS, syncToolLinks } from '../link/tool-links.js';
+function directoryName(identity) {
+    const [, scope, skillName] = identity.split('/');
+    return `${scope}_${skillName}`;
+}
+function toSkill(identity) {
+    return { identity, directoryName: directoryName(identity) };
+}
+function toTarget(result) {
+    return { ...toSkill(result.identity), targetDir: result.targetDir };
+}
+function groupResults(results) {
+    const byTool = new Map();
+    for (const result of results) {
+        let entry = byTool.get(result.tool);
+        if (!entry) {
+            entry = {
+                tool: result.tool,
+                skills: [],
+                adopted: [],
+                skipped: [],
+                conflicts: [],
+                failed: []
+            };
+            byTool.set(result.tool, entry);
+        }
+        entry.skills.push(toSkill(result.identity));
+        if (result.status === 'created') {
+            entry.adopted.push(toTarget(result));
+        }
+        else if (result.status === 'existing') {
+            entry.skipped.push(toTarget(result));
+        }
+        else if (result.status === 'conflict') {
+            entry.conflicts.push(toTarget(result));
+        }
+        else if (result.status === 'failed') {
+            entry.failed.push(toTarget(result));
+        }
+    }
+    return Array.from(byTool.values());
+}
+async function resolveProjectTools(projectRoot, options) {
+    if (options.tools && options.tools.length > 0) {
+        return options.tools;
+    }
+    const skillsJson = await loadSkillsJson(projectRoot);
+    if (skillsJson.tools && skillsJson.tools.length > 0) {
+        return toConfiguredTools(skillsJson.tools);
+    }
+    const config = await loadConfig(options);
+    return toConfiguredTools(config.tools);
+}
+async function resolveGlobalTools(options) {
+    if (options.tools && options.tools.length > 0) {
+        return options.tools;
+    }
+    const config = await loadConfig(options);
+    return toConfiguredTools(config.tools);
+}
+function toConfiguredTools(tools) {
+    return tools.map((tool) => {
+        if (!isSupportedTool(tool)) {
+            throw new Error(`Unknown tool: ${tool}. Supported tools: ${SUPPORTED_TOOLS.join(', ')}`);
+        }
+        return tool;
+    });
+}
+export async function adaptProject(projectRoot, options = {}) {
+    const tools = await resolveProjectTools(projectRoot, options);
+    if (tools.length === 0) {
+        throw new Error('No tools configured. Run: esl install --tools <tools>');
+    }
+    const results = await syncToolLinks({
+        storeRoot: resolveProjectStorePaths(projectRoot).root,
+        level: 'project',
+        tools,
+        projectRoot,
+        homeDir: options.homeDir,
+        force: options.force
+    });
+    return groupResults(results);
+}
+export async function adaptGlobal(options = {}) {
+    const tools = await resolveGlobalTools(options);
+    if (tools.length === 0) {
+        throw new Error('No tools configured. Run: esl install --tools <tools>');
+    }
+    const results = await syncToolLinks({
+        storeRoot: resolveLocalStorePaths(options).root,
+        level: 'global',
+        tools,
+        homeDir: options.homeDir,
+        force: options.force
+    });
+    return groupResults(results);
+}

package/dist/vendor/core/adapt/adapted-skill-copy.d.ts

@@ -0,0 +1,2 @@
+import type { AdaptedSkill } from './tool-adapter.js';
+export declare function copyAdaptedSkill(skillSourceDir: string, skill: AdaptedSkill, targetBaseDir: string): Promise<void>;

package/dist/vendor/core/adapt/adapted-skill-copy.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { copySkillDirectory } from '../store/file-copy.js';
+export async function copyAdaptedSkill(skillSourceDir, skill, targetBaseDir) {
+    const targetDir = path.join(targetBaseDir, skill.directoryName);
+    await copySkillDirectory(skillSourceDir, targetDir);
+    await rewriteSkillMdName(path.join(targetDir, 'SKILL.md'), skill.displayName);
+}
+async function rewriteSkillMdName(skillMdPath, displayName) {
+    const content = await fs.readFile(skillMdPath, 'utf8');
+    const updated = content.replace(/^(---\r?\n)([\s\S]*?)(\r?\n---)/, (_match, open, frontmatter, close) => {
+        return `${open}${frontmatter.replace(/(^name:\s*)[^\r\n]+/m, `$1${displayName}`)}${close}`;
+    });
+    await fs.chmod(skillMdPath, 0o666);
+    await fs.writeFile(skillMdPath, updated, 'utf8');
+    await fs.chmod(skillMdPath, 0o444);
+}

package/dist/vendor/core/adapt/claude-adapter.d.ts

@@ -0,0 +1,8 @@
+import type { AdaptedSkill, ToolAdapter } from './tool-adapter.js';
+export declare class ClaudeAdapter implements ToolAdapter {
+    readonly name = "claude";
+    projectDir(root: string): string;
+    globalDir(homeDir?: string): string;
+    adapt(skillSourceDir: string, skill: AdaptedSkill, targetBaseDir: string): Promise<void>;
+    clean(targetBaseDir: string): Promise<void>;
+}

package/dist/vendor/core/adapt/claude-adapter.js

@@ -0,0 +1,19 @@
+import os from 'node:os';
+import path from 'node:path';
+import { removeDirectory } from '../store/file-copy.js';
+import { copyAdaptedSkill } from './adapted-skill-copy.js';
+export class ClaudeAdapter {
+    name = 'claude';
+    projectDir(root) {
+        return path.join(root, '.claude', 'skills');
+    }
+    globalDir(homeDir = os.homedir()) {
+        return path.join(homeDir, '.claude', 'skills');
+    }
+    async adapt(skillSourceDir, skill, targetBaseDir) {
+        await copyAdaptedSkill(skillSourceDir, skill, targetBaseDir);
+    }
+    async clean(targetBaseDir) {
+        await removeDirectory(targetBaseDir);
+    }
+}

package/dist/vendor/core/adapt/codex-adapter.d.ts

@@ -0,0 +1,8 @@
+import type { AdaptedSkill, ToolAdapter } from './tool-adapter.js';
+export declare class CodexAdapter implements ToolAdapter {
+    readonly name = "codex";
+    projectDir(root: string): string;
+    globalDir(homeDir?: string): string;
+    adapt(skillSourceDir: string, skill: AdaptedSkill, targetBaseDir: string): Promise<void>;
+    clean(targetBaseDir: string): Promise<void>;
+}

package/dist/vendor/core/adapt/codex-adapter.js

@@ -0,0 +1,19 @@
+import os from 'node:os';
+import path from 'node:path';
+import { removeDirectory } from '../store/file-copy.js';
+import { copyAdaptedSkill } from './adapted-skill-copy.js';
+export class CodexAdapter {
+    name = 'codex';
+    projectDir(root) {
+        return path.join(root, '.agents', 'skills');
+    }
+    globalDir(homeDir = os.homedir()) {
+        return path.join(homeDir, '.agents', 'skills');
+    }
+    async adapt(skillSourceDir, skill, targetBaseDir) {
+        await copyAdaptedSkill(skillSourceDir, skill, targetBaseDir);
+    }
+    async clean(targetBaseDir) {
+        await removeDirectory(targetBaseDir);
+    }
+}

package/dist/vendor/core/adapt/index.d.ts

@@ -0,0 +1,2 @@
+export { adaptGlobal, adaptProject, type AdaptResult } from './adapt-engine.js';
+export { SUPPORTED_TOOLS, isSupportedTool, parseToolSelection, toolDirectory, type ToolName } from '../link/tool-links.js';

package/dist/vendor/core/adapt/index.js

@@ -0,0 +1,2 @@
+export { adaptGlobal, adaptProject } from './adapt-engine.js';
+export { SUPPORTED_TOOLS, isSupportedTool, parseToolSelection, toolDirectory } from '../link/tool-links.js';

package/dist/vendor/core/adapt/tool-adapter.d.ts

@@ -0,0 +1,12 @@
+export interface AdaptedSkill {
+    identity: string;
+    directoryName: string;
+    displayName: string;
+}
+export interface ToolAdapter {
+    name: string;
+    projectDir(root: string): string;
+    globalDir(homeDir?: string): string;
+    adapt(skillSourceDir: string, skill: AdaptedSkill, targetBaseDir: string): Promise<void>;
+    clean(targetBaseDir: string): Promise<void>;
+}

package/dist/vendor/core/adapt/tool-adapter.js

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

package/dist/vendor/core/adapt/trae-adapter.d.ts

@@ -0,0 +1,8 @@
+import type { AdaptedSkill, ToolAdapter } from './tool-adapter.js';
+export declare class TraeAdapter implements ToolAdapter {
+    readonly name = "trae";
+    projectDir(root: string): string;
+    globalDir(homeDir?: string): string;
+    adapt(skillSourceDir: string, skill: AdaptedSkill, targetBaseDir: string): Promise<void>;
+    clean(targetBaseDir: string): Promise<void>;
+}

package/dist/vendor/core/adapt/trae-adapter.js

@@ -0,0 +1,19 @@
+import os from 'node:os';
+import path from 'node:path';
+import { removeDirectory } from '../store/file-copy.js';
+import { copyAdaptedSkill } from './adapted-skill-copy.js';
+export class TraeAdapter {
+    name = 'trae';
+    projectDir(root) {
+        return path.join(root, '.trae', 'skills');
+    }
+    globalDir(homeDir = os.homedir()) {
+        return path.join(homeDir, '.trae', 'skills');
+    }
+    async adapt(skillSourceDir, skill, targetBaseDir) {
+        await copyAdaptedSkill(skillSourceDir, skill, targetBaseDir);
+    }
+    async clean(targetBaseDir) {
+        await removeDirectory(targetBaseDir);
+    }
+}

package/dist/vendor/core/adapt/trae-cn-adapter.d.ts

@@ -0,0 +1,8 @@
+import type { AdaptedSkill, ToolAdapter } from './tool-adapter.js';
+export declare class TraeCnAdapter implements ToolAdapter {
+    readonly name = "trae-cn";
+    projectDir(root: string): string;
+    globalDir(homeDir?: string): string;
+    adapt(skillSourceDir: string, skill: AdaptedSkill, targetBaseDir: string): Promise<void>;
+    clean(targetBaseDir: string): Promise<void>;
+}

package/dist/vendor/core/adapt/trae-cn-adapter.js

@@ -0,0 +1,19 @@
+import os from 'node:os';
+import path from 'node:path';
+import { removeDirectory } from '../store/file-copy.js';
+import { copyAdaptedSkill } from './adapted-skill-copy.js';
+export class TraeCnAdapter {
+    name = 'trae-cn';
+    projectDir(root) {
+        return path.join(root, '.trae', 'skills');
+    }
+    globalDir(homeDir = os.homedir()) {
+        return path.join(homeDir, '.trae-cn', 'skills');
+    }
+    async adapt(skillSourceDir, skill, targetBaseDir) {
+        await copyAdaptedSkill(skillSourceDir, skill, targetBaseDir);
+    }
+    async clean(targetBaseDir) {
+        await removeDirectory(targetBaseDir);
+    }
+}