@foxian/esl 0.1.0

package/dist/vendor/core/agent-interaction.d.ts

@@ -0,0 +1,58 @@
+import type { ToolName } from './link/tool-links.js';
+export declare const AGENT_INTERACTION_REQUEST_TYPE = "esl.interaction.request";
+export declare const AGENT_INTERACTION_SCHEMA_VERSION = 1;
+export type AgentInteractionFieldKind = 'text' | 'textarea' | 'select' | 'multiselect' | 'confirm' | 'path';
+export interface AgentInteractionOption {
+    label: string;
+    description?: string;
+}
+export interface AgentInteractionField {
+    id: string;
+    kind: AgentInteractionFieldKind;
+    label: string;
+    description?: string;
+    required?: boolean;
+    default?: string | boolean | string[];
+    options?: Array<string | AgentInteractionOption>;
+}
+export interface AgentInteractionRequest {
+    type: typeof AGENT_INTERACTION_REQUEST_TYPE;
+    schemaVersion: typeof AGENT_INTERACTION_SCHEMA_VERSION;
+    requestId: string;
+    command: string;
+    /** 发起本次调用的 AI 工具标识，来自 --agent-tool。 */
+    agentTool?: ToolName;
+    fields: AgentInteractionField[];
+}
+export interface AgentInteractionRequestInput {
+    command: string;
+    fields: AgentInteractionField[];
+    requestId?: string;
+    agentTool?: ToolName;
+}
+export declare function createAgentInteractionRequest(input: AgentInteractionRequestInput): AgentInteractionRequest;
+/** Claude Code AskUserQuestion 输入中单个选项。 */
+export interface AskUserQuestionOption {
+    label: string;
+    description?: string;
+}
+/** Claude Code AskUserQuestion 输入中的单个问题。 */
+export interface AskUserQuestionQuestion {
+    question: string;
+    header: string;
+    options: AskUserQuestionOption[];
+    multiSelect: boolean;
+}
+/** 与 Claude Code AskUserQuestion 工具输入一致的请求负载。 */
+export interface AskUserQuestionPayload {
+    questions: AskUserQuestionQuestion[];
+    metadata?: {
+        source?: string;
+    };
+}
+/** 把内部交互字段映射为 Claude Code AskUserQuestion 风格的 JSON 负载。 */
+export declare function toAskUserQuestionPayload(request: AgentInteractionRequest): AskUserQuestionPayload;
+export declare class AgentInteractionRequiredError extends Error {
+    readonly request: AgentInteractionRequest;
+    constructor(request: AgentInteractionRequest);
+}

package/dist/vendor/core/agent-interaction.js

@@ -0,0 +1,58 @@
+import { randomUUID } from 'node:crypto';
+export const AGENT_INTERACTION_REQUEST_TYPE = 'esl.interaction.request';
+export const AGENT_INTERACTION_SCHEMA_VERSION = 1;
+export function createAgentInteractionRequest(input) {
+    return {
+        type: AGENT_INTERACTION_REQUEST_TYPE,
+        schemaVersion: AGENT_INTERACTION_SCHEMA_VERSION,
+        requestId: input.requestId ?? `ir_${randomUUID()}`,
+        command: input.command,
+        ...(input.agentTool !== undefined ? { agentTool: input.agentTool } : {}),
+        fields: input.fields
+    };
+}
+const ASK_USER_QUESTION_SOURCE = 'esl-cli';
+/** 把字段映射为 AskUserQuestion 的一个问题；question/header 复用字段 label。 */
+function fieldToAskUserQuestionQuestion(field) {
+    const question = field.label;
+    let options;
+    switch (field.kind) {
+        case 'select':
+        case 'multiselect':
+            options = (field.options ?? []).map((option) => typeof option === 'string' ? { label: option } : option);
+            break;
+        case 'confirm':
+            options = [
+                { label: 'yes', description: '确认' },
+                { label: 'no', description: '取消' }
+            ];
+            break;
+        default:
+            // text / textarea / path：AskUserQuestion 只做选择题，把默认值作为快捷选项，
+            // 自定义文本由用户走 Other 输入；没有默认值时不臆造选项。
+            options =
+                field.default !== undefined ? [{ label: String(field.default), description: '默认值' }] : [];
+            break;
+    }
+    return {
+        question,
+        header: question,
+        options,
+        multiSelect: field.kind === 'multiselect'
+    };
+}
+/** 把内部交互字段映射为 Claude Code AskUserQuestion 风格的 JSON 负载。 */
+export function toAskUserQuestionPayload(request) {
+    return {
+        questions: request.fields.map(fieldToAskUserQuestionQuestion),
+        metadata: { source: ASK_USER_QUESTION_SOURCE }
+    };
+}
+export class AgentInteractionRequiredError extends Error {
+    request;
+    constructor(request) {
+        super(`Command ${request.command} requires user interaction`);
+        this.name = 'AgentInteractionRequiredError';
+        this.request = request;
+    }
+}

package/dist/vendor/core/command-params.d.ts

@@ -0,0 +1,5 @@
+export type CommandParams = Record<string, unknown>;
+export declare function parseCommandParams(raw: string, command: string, allowedKeys: readonly string[]): CommandParams;
+export declare function readOptionalStringParam(params: CommandParams, key: string, command: string): string | undefined;
+export declare function readOptionalStringArrayParam(params: CommandParams, key: string, command: string): string[] | undefined;
+export declare function assertNoDuplicateCommandParams(params: CommandParams, explicitFlags: Record<string, unknown>, command: string): void;

package/dist/vendor/core/command-params.js

@@ -0,0 +1,46 @@
+export function parseCommandParams(raw, command, allowedKeys) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Invalid --params-json for ${command}: expected valid JSON`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Invalid --params-json for ${command}: expected a JSON object`);
+    }
+    const params = parsed;
+    const unknownKeys = Object.keys(params).filter((key) => !allowedKeys.includes(key));
+    if (unknownKeys.length > 0) {
+        throw new Error(`Invalid --params-json for ${command}: unknown parameter${unknownKeys.length === 1 ? '' : 's'} ${unknownKeys.join(', ')}`);
+    }
+    return params;
+}
+export function readOptionalStringParam(params, key, command) {
+    const value = params[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Invalid --params-json for ${command}: "${key}" must be a string`);
+    }
+    return value;
+}
+export function readOptionalStringArrayParam(params, key, command) {
+    const value = params[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string')) {
+        throw new Error(`Invalid --params-json for ${command}: "${key}" must be an array of strings`);
+    }
+    return value;
+}
+export function assertNoDuplicateCommandParams(params, explicitFlags, command) {
+    const duplicates = Object.entries(explicitFlags)
+        .filter(([key, value]) => value !== undefined && params[key] !== undefined)
+        .map(([key]) => key);
+    if (duplicates.length > 0) {
+        throw new Error(`Parameter${duplicates.length === 1 ? '' : 's'} ${duplicates.join(', ')} cannot be passed both as a flag and in --params-json`);
+    }
+}

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

@@ -0,0 +1,22 @@
+export declare const VERSION = "0.1.0";
+export * from './agent-interaction.js';
+export * from './command-params.js';
+export * from './adapt/index.js';
+export * from './org/org-name.js';
+export * from './org/standing-teams.js';
+export * from './org/account-policy.js';
+export * from './schema/skill-json.js';
+export * from './schema/release-manifest.js';
+export * from './schema/compatibility.js';
+export * from './schema/validation-result.js';
+export * from './skill/builtin-package.js';
+export * from './skill/directory-validator.js';
+export * from './skill/published-package.js';
+export * from './skill/skill-md.js';
+export * from './version/select-version.js';
+export * from './store/file-copy.js';
+export * from './store/local-store.js';
+export * from './store/skills-json.js';
+export * from './link/tool-links.js';
+export * from './link/skill-links.js';
+export * from './store/skill-store.js';

package/dist/vendor/core/index.js

@@ -0,0 +1,22 @@
+export const VERSION = '0.1.0';
+export * from './agent-interaction.js';
+export * from './command-params.js';
+export * from './adapt/index.js';
+export * from './org/org-name.js';
+export * from './org/standing-teams.js';
+export * from './org/account-policy.js';
+export * from './schema/skill-json.js';
+export * from './schema/release-manifest.js';
+export * from './schema/compatibility.js';
+export * from './schema/validation-result.js';
+export * from './skill/builtin-package.js';
+export * from './skill/directory-validator.js';
+export * from './skill/published-package.js';
+export * from './skill/skill-md.js';
+export * from './version/select-version.js';
+export * from './store/file-copy.js';
+export * from './store/local-store.js';
+export * from './store/skills-json.js';
+export * from './link/tool-links.js';
+export * from './link/skill-links.js';
+export * from './store/skill-store.js';

package/dist/vendor/core/link/skill-links.d.ts

@@ -0,0 +1,38 @@
+import type { SkillsLockEntry } from '../store/skills-json.js';
+import { type InstallManifestSkill } from '../store/skill-store.js';
+export interface LinkStagingMetadata {
+    dependencySpecifier?: string;
+    lockEntry?: SkillsLockEntry;
+    manifestEntry?: InstallManifestSkill;
+}
+export interface LinkStagingRecord extends LinkStagingMetadata {
+    identity: string;
+    sourceDir: string;
+    originalDir: string;
+    stagedDir: string;
+}
+export interface LinkSkillOptions {
+    identity: string;
+    sourceDir: string;
+    storeRoot: string;
+    force?: boolean;
+    previous?: LinkStagingMetadata;
+}
+export interface LinkSkillResult {
+    identity: string;
+    sourceDir: string;
+    targetDir: string;
+    status: 'linked' | 'relinked';
+    staged: boolean;
+}
+export interface UnlinkSkillDirectoryResult {
+    restored: boolean;
+    record?: LinkStagingRecord;
+}
+export declare function linkStagingRelativeDir(): string;
+export declare function linkStagingRecordPath(storeRoot: string): string;
+export declare function linkSkillDirectory(options: LinkSkillOptions): Promise<LinkSkillResult>;
+export declare function hasLinkStagingRecord(identity: string, storeRoot: string): Promise<boolean>;
+export declare function unlinkSkillDirectory(identity: string, storeRoot: string): Promise<UnlinkSkillDirectoryResult>;
+export declare function removeLinkedSkillDirectory(identity: string, storeRoot: string): Promise<void>;
+export declare function isLinkedSkill(identity: string, storeRoot: string): Promise<boolean>;

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

@@ -0,0 +1,245 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { skillSourceDirectoryName, skillSourceRelativeDir } from '../store/skill-store.js';
+const LINK_STAGING_RECORD_FILE = '.esl-link-staging.json';
+export function linkStagingRelativeDir() {
+    return path.join('link-staging');
+}
+export function linkStagingRecordPath(storeRoot) {
+    return path.join(storeRoot, LINK_STAGING_RECORD_FILE);
+}
+function linkStagingDir(storeRoot, identity) {
+    return path.join(storeRoot, linkStagingRelativeDir(), skillSourceDirectoryName(identity));
+}
+async function loadLinkStagingStore(storeRoot) {
+    try {
+        const raw = await fs.readFile(linkStagingRecordPath(storeRoot), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            throw new Error('Invalid ESL link staging record');
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return {};
+        }
+        throw error;
+    }
+}
+async function saveLinkStagingStore(storeRoot, records) {
+    await fs.mkdir(storeRoot, { recursive: true });
+    await fs.writeFile(linkStagingRecordPath(storeRoot), `${JSON.stringify(records, null, 2)}\n`, 'utf8');
+}
+async function isSymbolicLink(targetDir) {
+    try {
+        const stat = await fs.lstat(targetDir);
+        return stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+async function directoryExists(dir) {
+    try {
+        const stat = await fs.stat(dir);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readLinkTarget(linkPath) {
+    const target = await fs.readlink(linkPath);
+    return path.resolve(path.dirname(linkPath), target);
+}
+function samePath(left, right) {
+    const normalizedLeft = path.resolve(left);
+    const normalizedRight = path.resolve(right);
+    return process.platform === 'win32'
+        ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+        : normalizedLeft === normalizedRight;
+}
+function isInside(parent, candidate) {
+    const relative = path.relative(path.resolve(parent), path.resolve(candidate));
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+async function createSourceLink(sourceDir, targetDir) {
+    if (process.platform === 'win32') {
+        await fs.symlink(sourceDir, targetDir, 'junction');
+    }
+    else {
+        await fs.symlink(sourceDir, targetDir, 'dir');
+    }
+}
+async function assertStagingAvailable(storeRoot, identity, stagedDir) {
+    const records = await loadLinkStagingStore(storeRoot);
+    if (records[identity]) {
+        throw new Error(`Link staging already contains ${identity}`);
+    }
+    try {
+        await fs.access(stagedDir);
+        throw new Error(`Unexpected content exists at link staging path for ${identity}`);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+}
+async function stageOriginalDirectory(options) {
+    const { identity, sourceDir, storeRoot, targetDir, stagedDir, metadata } = options;
+    const record = {
+        identity,
+        sourceDir,
+        originalDir: targetDir,
+        stagedDir,
+        ...(metadata ?? {})
+    };
+    await fs.mkdir(path.dirname(stagedDir), { recursive: true });
+    await fs.rename(targetDir, stagedDir);
+    const records = await loadLinkStagingStore(storeRoot);
+    records[identity] = record;
+    try {
+        await saveLinkStagingStore(storeRoot, records);
+        await fs.mkdir(path.dirname(targetDir), { recursive: true });
+        await createSourceLink(sourceDir, targetDir);
+    }
+    catch (error) {
+        const rollbackRecords = await loadLinkStagingStore(storeRoot);
+        delete rollbackRecords[identity];
+        try {
+            await saveLinkStagingStore(storeRoot, rollbackRecords);
+            await fs.rename(stagedDir, targetDir);
+        }
+        catch (rollbackError) {
+            throw new Error(`Failed to create skill source link and roll back staging: ${rollbackError.message}`, { cause: error });
+        }
+        throw error;
+    }
+}
+export async function linkSkillDirectory(options) {
+    const { identity, storeRoot, force = false } = options;
+    const sourceDir = path.resolve(options.sourceDir);
+    const targetDir = path.resolve(storeRoot, skillSourceRelativeDir(identity));
+    const stagedDir = linkStagingDir(storeRoot, identity);
+    if (!(await directoryExists(sourceDir))) {
+        throw new Error(`Skill source directory does not exist: ${sourceDir}`);
+    }
+    if (isInside(sourceDir, targetDir)) {
+        throw new Error(`Skill source link target must not be inside the source directory: ${targetDir}`);
+    }
+    if (await isSymbolicLink(targetDir)) {
+        const currentTarget = await readLinkTarget(targetDir);
+        if (samePath(currentTarget, sourceDir)) {
+            return { identity, sourceDir, targetDir, status: 'linked', staged: false };
+        }
+        if (!force) {
+            throw new Error(`Skill ${identity} is already linked to ${currentTarget}; use --force to replace it`);
+        }
+        await fs.rm(targetDir, { force: true });
+        await fs.mkdir(path.dirname(targetDir), { recursive: true });
+        await createSourceLink(sourceDir, targetDir);
+        return { identity, sourceDir, targetDir, status: 'relinked', staged: false };
+    }
+    if (await directoryExists(targetDir)) {
+        if (!force) {
+            throw new Error(`Skill ${identity} is already installed at ${targetDir}; use --force to link it`);
+        }
+        await assertStagingAvailable(storeRoot, identity, stagedDir);
+        await stageOriginalDirectory({
+            identity,
+            sourceDir,
+            storeRoot,
+            targetDir,
+            stagedDir,
+            metadata: options.previous
+        });
+        return { identity, sourceDir, targetDir, status: 'relinked', staged: true };
+    }
+    try {
+        await fs.lstat(targetDir);
+        throw new Error(`Skill target must not be a regular file: ${targetDir}`);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await fs.mkdir(path.dirname(targetDir), { recursive: true });
+    await createSourceLink(sourceDir, targetDir);
+    return { identity, sourceDir, targetDir, status: 'linked', staged: false };
+}
+export async function hasLinkStagingRecord(identity, storeRoot) {
+    const records = await loadLinkStagingStore(storeRoot);
+    return Boolean(records[identity]);
+}
+export async function unlinkSkillDirectory(identity, storeRoot) {
+    const targetDir = path.resolve(storeRoot, skillSourceRelativeDir(identity));
+    const records = await loadLinkStagingStore(storeRoot);
+    const record = records[identity];
+    if (!await isSymbolicLink(targetDir)) {
+        try {
+            await fs.lstat(targetDir);
+            throw new Error(`Skill ${identity} target is not a skill source link: ${targetDir}`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    if (!record) {
+        await fs.rm(targetDir, { force: true });
+        return { restored: false };
+    }
+    if (!(await directoryExists(record.stagedDir))) {
+        throw new Error(`Link staging for ${identity} is missing its original copy; link state was kept`);
+    }
+    if (!samePath(record.originalDir, targetDir)) {
+        throw new Error(`Link staging for ${identity} points to an unexpected original location`);
+    }
+    await fs.rm(targetDir, { force: true });
+    try {
+        await fs.mkdir(path.dirname(targetDir), { recursive: true });
+        await fs.rename(record.stagedDir, targetDir);
+    }
+    catch (error) {
+        await createSourceLink(record.sourceDir, targetDir);
+        throw error;
+    }
+    delete records[identity];
+    await saveLinkStagingStore(storeRoot, records);
+    await fs.rmdir(path.dirname(record.stagedDir)).catch(() => { });
+    await fs.rmdir(path.join(storeRoot, linkStagingRelativeDir())).catch(() => { });
+    return { restored: true, record };
+}
+export async function removeLinkedSkillDirectory(identity, storeRoot) {
+    const targetDir = path.resolve(storeRoot, skillSourceRelativeDir(identity));
+    const records = await loadLinkStagingStore(storeRoot);
+    const record = records[identity];
+    if (!await isSymbolicLink(targetDir)) {
+        try {
+            await fs.lstat(targetDir);
+            throw new Error(`Skill ${identity} target is not a skill source link: ${targetDir}`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    await fs.rm(targetDir, { force: true });
+    if (record) {
+        if (!(await directoryExists(record.stagedDir))) {
+            throw new Error(`Link staging for ${identity} is missing its original copy`);
+        }
+        await fs.rm(record.stagedDir, { recursive: true, force: true });
+        delete records[identity];
+        await saveLinkStagingStore(storeRoot, records);
+    }
+}
+export async function isLinkedSkill(identity, storeRoot) {
+    const targetDir = path.resolve(storeRoot, skillSourceRelativeDir(identity));
+    return isSymbolicLink(targetDir);
+}

package/dist/vendor/core/link/tool-links.d.ts

@@ -0,0 +1,83 @@
+export declare const SUPPORTED_TOOLS: readonly ["claude", "codex", "cursor", "trae-intl", "trae-cn", "workbuddy", "opencode", "openclaw", "hermes"];
+export type ToolName = (typeof SUPPORTED_TOOLS)[number];
+export type ToolLevel = 'project' | 'global';
+export type ToolLinkStatus = 'linked' | 'broken' | 'conflict' | 'source-only' | 'unmanaged';
+export interface ToolLinkRecord {
+    identity: string;
+    tool: ToolName;
+    level: ToolLevel;
+    sourceDir: string;
+    targetDir: string;
+    createdAt: string;
+}
+export interface ToolLinkManifest {
+    version: 1;
+    links: ToolLinkRecord[];
+}
+export interface ToolLinkEntry {
+    tool: ToolName | 'source';
+    identity: string;
+    level: ToolLevel;
+    status: ToolLinkStatus;
+    managed: boolean;
+    sourceDir: string;
+    targetDir?: string;
+}
+export interface CreateToolLinkOptions {
+    identity: string;
+    tool: ToolName;
+    level: ToolLevel;
+    storeRoot: string;
+    projectRoot?: string;
+    homeDir?: string;
+    force?: boolean;
+}
+export interface ToolLinkOperationResult {
+    identity: string;
+    tool: ToolName;
+    targetDir: string;
+    status: 'created' | 'existing' | 'conflict' | 'failed';
+    error?: string;
+}
+export declare function isSupportedTool(value: string): value is ToolName;
+export declare function resolveToolName(value: string): ToolName | undefined;
+export declare function parseToolSelection(value: string): ToolName[];
+export declare function toolDirectory(tool: ToolName, level: ToolLevel, options?: {
+    projectRoot?: string;
+    homeDir?: string;
+}): string;
+export declare function toolLinkManifestPath(storeRoot: string): string;
+export declare function defaultToolLinkManifest(): ToolLinkManifest;
+export declare function loadToolLinkManifest(storeRoot: string): Promise<ToolLinkManifest>;
+export declare function saveToolLinkManifest(storeRoot: string, manifest: ToolLinkManifest): Promise<void>;
+export declare function createToolLink(options: CreateToolLinkOptions): Promise<ToolLinkOperationResult>;
+export interface SyncToolLinksOptions {
+    storeRoot: string;
+    level: ToolLevel;
+    tools: ToolName[];
+    identities?: string[];
+    projectRoot?: string;
+    homeDir?: string;
+    force?: boolean;
+}
+export declare function syncToolLinks(options: SyncToolLinksOptions): Promise<ToolLinkOperationResult[]>;
+export interface RemoveToolLinksOptions {
+    storeRoot: string;
+    identity: string;
+    tools: ToolName[];
+    level: ToolLevel;
+}
+export interface RemovedToolLinkResult {
+    identity: string;
+    tool: ToolName;
+    targetDir: string;
+    status: 'removed' | 'missing' | 'conflict';
+}
+export declare function removeToolLinks(options: RemoveToolLinksOptions): Promise<RemovedToolLinkResult[]>;
+export interface ListToolLinksOptions {
+    storeRoot: string;
+    level: ToolLevel;
+    projectRoot?: string;
+    homeDir?: string;
+}
+export declare function listToolLinks(options: ListToolLinksOptions): Promise<ToolLinkEntry[]>;