@easbot/skills 0.3.10 → 0.3.12

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { AgentResult } from '@vercel/detect-agent';
+import { Lang } from '@easbot/utils';
 import { IGlobal, IInstance, ISubAgentRunner } from '@easbot/types';
 
 type AgentType = 'aider-desk' | 'amp' | 'antigravity' | 'easbot' | 'antigravity-cli' | 'astrbot' | 'autohand-code' | 'augment' | 'bob' | 'claude-code' | 'openclaw' | 'cline' | 'codearts-agent' | 'codebuddy' | 'codemaker' | 'codestudio' | 'codex' | 'command-code' | 'continue' | 'cortex' | 'crush' | 'cursor' | 'deepagents' | 'devin' | 'dexto' | 'droid' | 'eve' | 'firebender' | 'forgecode' | 'gemini-cli' | 'github-copilot' | 'goose' | 'hermes-agent' | 'inference-sh' | 'iflow-cli' | 'jazz' | 'junie' | 'kilo' | 'kimi-code-cli' | 'kiro-cli' | 'kode' | 'lingma' | 'loaf' | 'mcpjam' | 'mistral-vibe' | 'moxby' | 'mux' | 'neovate' | 'opencode' | 'openhands' | 'ona' | 'pi' | 'qoder' | 'qoder-cn' | 'qwen-code' | 'replit' | 'reasonix' | 'roo' | 'rovodev' | 'tabnine-cli' | 'terramind' | 'tinycloud' | 'trae' | 'trae-cn' | 'warp' | 'windsurf' | 'zed' | 'zencoder' | 'zenflow' | 'pochi' | 'promptscript' | 'adal' | 'universal';
@@ -16,8 +17,6 @@ interface AgentConfig {
     skillsDir: string;
     globalSkillsDir: string | undefined;
     detectInstalled: () => Promise<boolean>;
-    showInUniversalList?: boolean;
-    showInUniversalPrompt?: boolean;
 }
 interface ParsedSource {
     type: 'github' | 'gitlab' | 'git' | 'local' | 'well-known';
@@ -25,7 +24,6 @@ interface ParsedSource {
     subpath?: string;
     localPath?: string;
     ref?: string;
-    skillFilter?: string;
 }
 interface RemoteSkill$1 {
     name: string;
@@ -44,10 +42,21 @@ declare function detectInstalledAgents(): Promise<AgentType[]>;
 declare function getAgentConfig(type: AgentType): AgentConfig;
 declare const EVE_SUBAGENTS_DIR: string;
 declare function getEveSubagents(cwd?: string): string[];
-declare function getUniversalAgents(): AgentType[];
-declare function getVisibleUniversalAgents(): AgentType[];
-declare function getNonUniversalAgents(): AgentType[];
-declare function isUniversalAgent(type: AgentType): boolean;
+type UniversalScope = 'project' | 'global';
+declare function matchesUniversalScope(type: AgentType, scope: UniversalScope): boolean;
+declare function getUniversalAgents(scope: 'project' | 'global'): AgentType[];
+declare function getNonUniversalAgents(scope: 'project' | 'global'): AgentType[];
+declare const PROJECT_SKILLS_DIR_PATTERN: RegExp;
+declare function getAgentProjectSkillDirs(): string[];
+declare function getAgentGlobalSkillDirs(): string[];
+interface AgentSkillDirsResult {
+    readonly project: string[];
+    readonly global: string[];
+    readonly all: string[];
+}
+declare function getAgentSkillDirs(): AgentSkillDirsResult;
+declare function getAgentProjectSkillContainerPrefixes(): string[];
+declare function isUniversalAgent(type: AgentType, scope: 'project' | 'global'): boolean;
 
 declare function shouldInstallInternalSkills(): boolean;
 declare function parseSkillMd(skillMdPath: string, options?: {
@@ -62,6 +71,74 @@ declare function discoverSkills(basePath: string, subpath?: string, options?: Di
 declare function getSkillDisplayName(skill: Skill): string;
 declare function filterSkills(skills: Skill[], inputNames: string[]): Skill[];
 
+type InstallState = 'absent' | 'symlinked' | 'copied' | 'orphan' | 'divergent';
+type CellScope = 'global' | 'project';
+interface InstallCell {
+    readonly scope: CellScope;
+    readonly state: InstallState;
+    readonly targetPath: string;
+    readonly sourceRealpath?: string;
+    readonly sourceDir: string;
+}
+interface AgentInstallMatrix {
+    readonly agentId: AgentType;
+    readonly cells: {
+        readonly global: InstallCell;
+        readonly project: InstallCell;
+    };
+}
+type CellAction = {
+    readonly kind: 'install';
+    readonly agentId: AgentType;
+    readonly scope: CellScope;
+    readonly mode: InstallMode;
+    readonly targetPath: string;
+} | {
+    readonly kind: 'skip';
+    readonly agentId: AgentType;
+    readonly scope: CellScope;
+    readonly state: 'symlinked' | 'copied';
+} | {
+    readonly kind: 'report';
+    readonly agentId: AgentType;
+    readonly scope: CellScope;
+    readonly state: 'divergent' | 'orphan';
+};
+
+interface PostInstallInput {
+    readonly skillId: string;
+    readonly sourceDir: string;
+    readonly targetAgents: readonly AgentType[];
+    readonly installGlobally: boolean;
+    readonly defaultMode: 'symlink' | 'copy';
+    readonly assumeYes: boolean;
+    readonly cwd?: string;
+    readonly includeEveSubagents?: boolean;
+}
+interface PostInstallResult {
+    readonly skipped: boolean;
+    readonly installed: readonly CellAction[];
+    readonly reported: readonly CellAction[];
+    readonly matrix?: readonly AgentInstallMatrix[];
+}
+declare function probeCell(targetPath: string, sourceDir: string): Promise<InstallState>;
+declare function planActions(matrix: readonly AgentInstallMatrix[], defaultMode: 'symlink' | 'copy'): CellAction[];
+declare function applyActions(actions: readonly CellAction[], ctx: {
+    readonly sourceDir: string;
+    readonly installGlobally: boolean;
+    readonly cwd: string;
+}): Promise<{
+    installed: CellAction[];
+    reported: CellAction[];
+}>;
+declare function buildMatrix(targetAgents: readonly AgentType[], ctx: {
+    skillId: string;
+    sourceDir: string;
+    cwd: string;
+    includeEveSubagents?: boolean;
+}): AgentInstallMatrix[];
+declare function runPostInstallReconcile(input: PostInstallInput): Promise<PostInstallResult>;
+
 interface RemoteSkill {
     name: string;
     description: string;
@@ -108,8 +185,23 @@ interface WellKnownSkillEntryV2 {
     url: string;
     digest: string;
 }
-type WellKnownIndex = WellKnownIndexV1 | WellKnownIndexV2;
-type WellKnownSkillEntry = WellKnownSkillEntryV1 | WellKnownSkillEntryV2;
+interface WellKnownSkillEntryEasbotV1 {
+    name: string;
+    description: string;
+    sourceUrl: string;
+    installName?: string;
+    category?: string;
+    version?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    skillPath?: string;
+}
+interface WellKnownIndexEasbotV1 {
+    $schema: string;
+    skills: WellKnownSkillEntryEasbotV1[];
+}
+type WellKnownIndex = WellKnownIndexV1 | WellKnownIndexV2 | WellKnownIndexEasbotV1;
+type WellKnownSkillEntry = WellKnownSkillEntryV1 | WellKnownSkillEntryV2 | WellKnownSkillEntryEasbotV1;
 type WellKnownFileContent = string | Uint8Array;
 type NormalizedWellKnownEntry = {
     version: '0.1.0';
@@ -127,6 +219,13 @@ type NormalizedWellKnownEntry = {
     artifactUrl: string;
     digest: string;
     indexEntry: WellKnownSkillEntryV2;
+} | {
+    version: 'easbot-v1';
+    name: string;
+    description: string;
+    skillMdUrl: string;
+    installName?: string;
+    indexEntry: WellKnownSkillEntryEasbotV1;
 };
 interface WellKnownSkill extends RemoteSkill {
     files: Map<string, WellKnownFileContent>;
@@ -150,10 +249,12 @@ declare class WellKnownProvider implements HostProvider {
     private getLegacySkillBaseUrl;
     private isValidSkillName;
     private isSafeLegacyFilePath;
+    private isValidSkillEntryEasbotV1;
     private isValidSkillEntryV1;
     private isValidSkillEntryV2;
     fetchSkill(url: string): Promise<RemoteSkill | null>;
     fetchSkillByEntry(baseUrlOrEntry: string | NormalizedWellKnownEntry, legacyEntry?: WellKnownSkillEntryV1, legacyWellKnownPath?: string): Promise<WellKnownSkill | null>;
+    private fetchEasbotV1SkillByEntry;
     private fetchLegacySkillByEntry;
     private fetchArtifactSkillByEntry;
     private createSkill;
@@ -182,6 +283,7 @@ interface InstallResult {
     mode: InstallMode;
     symlinkFailed?: boolean;
     skipped?: boolean;
+    skippedReason?: 'overwrite' | 'up-to-date';
     error?: string;
 }
 declare function sanitizeName(name: string): string;
@@ -243,7 +345,7 @@ interface InstalledSkill {
     agents: AgentType[];
 }
 declare function listInstalledSkills(options?: {
-    global?: boolean;
+    scope?: 'project' | 'global' | 'both';
     cwd?: string;
     agentFilter?: AgentType[];
 }): Promise<InstalledSkill[]>;
@@ -283,6 +385,9 @@ interface SearchSkill {
 }
 interface FindOptions {
     owner?: string;
+    json?: boolean;
+    local?: boolean;
+    path?: string;
 }
 interface ParseFindOptionsResult {
     query: string;
@@ -291,19 +396,119 @@ interface ParseFindOptionsResult {
 }
 declare function parseFindOptions(args: string[]): ParseFindOptionsResult;
 declare function searchSkillsAPI(query: string, owner?: string): Promise<SearchSkill[]>;
-declare function runFind(args: string[]): Promise<void>;
+declare function runFind(args: string[]): Promise<number>;
 
 interface ListOptions {
     global?: boolean;
+    project?: boolean;
     agent?: string[];
     json?: boolean;
+    all?: boolean;
+    yes?: boolean;
 }
 declare function parseListOptions(args: string[]): ListOptions;
-declare function runList(args: string[]): Promise<void>;
+declare function runList(args: string[], callOptions?: {
+    cwd?: string;
+}): Promise<void>;
+
+declare const DEFAULT_CLONE_TIMEOUT = 300000;
+interface GitHubRepoInfo {
+    owner: string;
+    repo: string;
+    slug: string;
+    sshUrl: string;
+}
+declare class GitCloneError extends Error {
+    readonly url: string;
+    readonly isTimeout: boolean;
+    readonly isAuthError: boolean;
+    constructor(message: string, url: string, isTimeout?: boolean, isAuthError?: boolean);
+}
+declare function parseGitHubRepoUrl(url: string): GitHubRepoInfo | null;
+declare function isGitHubHttpsCloneUrl(url: string): boolean;
+declare function isGitHubSsoAuthError(message: string): boolean;
+declare function cloneRepo(url: string, ref?: string, targetDir?: string): Promise<string>;
+declare function cleanupTempDir(dir: string): Promise<void>;
+
+interface SkillSnapshotFile {
+    path: string;
+    contents: string;
+}
+interface SkillDownloadResponse {
+    files: SkillSnapshotFile[];
+    hash: string;
+}
+interface BlobSkill extends Skill {
+    files: SkillSnapshotFile[];
+    snapshotHash: string;
+    repoPath: string;
+}
+declare const BLOB_ALLOWED_REPOS: Record<string, {
+    downloadUrl: (slug: string) => string;
+}>;
+declare function toSkillSlug(name: string): string;
+interface TreeEntry {
+    path: string;
+    type: 'blob' | 'tree';
+    sha: string;
+    size?: number;
+}
+interface RepoTree {
+    sha: string;
+    branch: string;
+    tree: TreeEntry[];
+}
+declare function resetRepoTreeAuthState(): void;
+declare function fetchRepoTree(ownerRepo: string, ref?: string, getToken?: () => string | null): Promise<RepoTree | null>;
+declare function getSkillFolderHashFromTree(tree: RepoTree, skillPath: string): string | null;
+declare function findSkillMdPaths(tree: RepoTree, subpath?: string): string[];
+interface BlobInstallResult {
+    skills: BlobSkill[];
+    tree: RepoTree;
+}
+declare function tryBlobInstall(ownerRepo: string, options?: {
+    subpath?: string;
+    ref?: string;
+    getToken?: () => string | null;
+    includeInternal?: boolean;
+}): Promise<BlobInstallResult | null>;
+
+type InstallScope = 'project' | 'global';
+type AcquireMode = 'install' | 'update';
+interface AcquireInput extends ParsedSource {
+    mode?: AcquireMode;
+    skillNames?: string[];
+    scope?: InstallScope;
+}
+interface AcquireResult {
+    tempDir: string;
+    cacheHit: boolean;
+    source: 'local-cp' | 'cache-clone' | 'cache-pull' | 'well-known-fetch' | 'blob-fetch';
+    cloneError?: GitCloneError | null;
+}
+declare function getSourceDir({ scope }: {
+    scope: InstallScope;
+}): string;
+declare function getCacheRoot(): string;
+declare function getCacheRepoDir(parsed: ParsedSource): string;
+declare function acquireSourceClone(input: AcquireInput): Promise<AcquireResult>;
+declare function ensureCachedSource(source: {
+    url: string;
+    ref?: string;
+    sourceId: string;
+}): Promise<string>;
+declare function installFromCache({ cachePath, skillName, scope, }: {
+    cachePath: string;
+    skillName: string;
+    scope: InstallScope;
+}): Promise<string>;
+declare function cleanCachedRepo(parsed: ParsedSource): Promise<void>;
+declare function cleanCache(): Promise<void>;
 
 interface RemoveOptions {
     global?: boolean;
     agent?: string[];
+    skill?: string[];
     yes?: boolean;
     all?: boolean;
 }
@@ -316,13 +521,14 @@ declare function parseRemoveOptions(args: string[]): {
 interface SkillLockEntry {
     source: string;
     sourceType: string;
-    sourceUrl: string;
     ref?: string;
     skillPath?: string;
-    skillFolderHash: string;
+    computedHash: string;
     installedAt: string;
     updatedAt: string;
-    pluginName?: string;
+    marketId: string;
+    pluginId: string;
+    marketplaceId?: string;
 }
 interface DismissedPrompts {
     findSkillsPrompt?: boolean;
@@ -331,7 +537,6 @@ interface SkillLockFile {
     version: number;
     skills: Record<string, SkillLockEntry>;
     dismissed?: DismissedPrompts;
-    lastSelectedAgents?: string[];
 }
 declare function getSkillLockPath(): string;
 declare function readSkillLock(): Promise<SkillLockFile>;
@@ -350,8 +555,6 @@ declare function getSkillsBySource(): Promise<Map<string, {
 }>>;
 declare function isPromptDismissed(promptKey: keyof DismissedPrompts): Promise<boolean>;
 declare function dismissPrompt(promptKey: keyof DismissedPrompts): Promise<void>;
-declare function getLastSelectedAgents(): Promise<string[] | undefined>;
-declare function saveSelectedAgents(agents: string[]): Promise<void>;
 
 interface LocalSkillLockEntry {
     source: string;
@@ -359,6 +562,11 @@ interface LocalSkillLockEntry {
     sourceType: string;
     skillPath?: string;
     computedHash: string;
+    installedAt: string;
+    updatedAt: string;
+    marketId: string;
+    pluginId: string;
+    marketplaceId?: string;
     subagents?: string[];
 }
 interface LocalSkillLockFile {
@@ -369,33 +577,48 @@ declare function getLocalLockPath(cwd?: string): string;
 declare function readLocalLock(cwd?: string): Promise<LocalSkillLockFile>;
 declare function writeLocalLock(lock: LocalSkillLockFile, cwd?: string): Promise<void>;
 declare function computeSkillFolderHash(skillDir: string): Promise<string>;
-declare function addSkillToLocalLock(skillName: string, entry: LocalSkillLockEntry, cwd?: string): Promise<void>;
+declare function addSkillToLocalLock(skillName: string, entry: Omit<LocalSkillLockEntry, 'installedAt' | 'updatedAt'>, cwd?: string): Promise<void>;
 declare function removeSkillFromLocalLock(skillName: string, cwd?: string): Promise<boolean>;
 
 type UpdateScope = 'project' | 'global' | 'both';
 interface UpdateCheckOptions {
+    cwd?: string;
     global?: boolean;
     project?: boolean;
     yes?: boolean;
+    all?: boolean;
+    agent?: string[];
+    force?: boolean;
     skills?: string[];
 }
-declare function parseUpdateOptions(args: string[]): UpdateCheckOptions;
+declare function parseUpdateOptions(args: string[], callOptions?: {
+    cwd?: string;
+}): UpdateCheckOptions;
 declare function hasProjectSkills(cwd?: string): boolean;
 declare function resolveUpdateScope(options: UpdateCheckOptions): Promise<UpdateScope>;
 declare function matchesSkillFilter(name: string, filter?: string[]): boolean;
-declare function runUpdate(args?: string[]): Promise<void>;
+declare function runUpdate(args?: string[], callOptions?: {
+    cwd?: string;
+}): Promise<void>;
 
-declare function runInstallFromLock(args: string[]): Promise<void>;
+declare function runDoctor(args: string[], callOptions?: {
+    cwd?: string;
+}): Promise<void>;
 
-interface SyncOptions {
-    agent?: string[];
-    yes?: boolean;
+interface StoreOptions {
     force?: boolean;
+    yes?: boolean;
+    json?: boolean;
 }
-declare function runSync(args: string[], options?: SyncOptions): Promise<void>;
-declare function parseSyncOptions(args: string[]): {
-    options: SyncOptions;
+declare function parseStoreOptions(args: string[]): {
+    subcommand: string;
+    restArgs: string[];
 };
+declare function runStore(args: string[], options?: StoreOptions): Promise<number>;
+declare function runStoreList(keyword: string | undefined, options?: StoreOptions): Promise<number>;
+declare function runStoreClean(options?: StoreOptions): Promise<number>;
+declare function runStoreUpdate(keyword: string | undefined, options?: StoreOptions): Promise<number>;
+declare function runStoreRemove(restArgs: string[], options?: StoreOptions): Promise<number>;
 
 interface UseOptions {
     skill?: string;
@@ -453,69 +676,6 @@ declare function materializeUseSkill(skill: UseSkill): Promise<MaterializedUseSk
 declare function runUse(sourceArgs: string[], options?: UseOptions, parseErrors?: string[]): Promise<void>;
 declare function launchAgentInteractively(agent: AgentType, prompt: string, spawnImpl?: AgentSpawn): Promise<number>;
 
-declare const DEFAULT_CLONE_TIMEOUT = 300000;
-interface GitHubRepoInfo {
-    owner: string;
-    repo: string;
-    slug: string;
-    sshUrl: string;
-}
-declare class GitCloneError extends Error {
-    readonly url: string;
-    readonly isTimeout: boolean;
-    readonly isAuthError: boolean;
-    constructor(message: string, url: string, isTimeout?: boolean, isAuthError?: boolean);
-}
-declare function parseGitHubRepoUrl(url: string): GitHubRepoInfo | null;
-declare function isGitHubHttpsCloneUrl(url: string): boolean;
-declare function isGitHubSsoAuthError(message: string): boolean;
-declare function cloneRepo(url: string, ref?: string): Promise<string>;
-declare function cleanupTempDir(dir: string): Promise<void>;
-
-interface SkillSnapshotFile {
-    path: string;
-    contents: string;
-}
-interface SkillDownloadResponse {
-    files: SkillSnapshotFile[];
-    hash: string;
-}
-interface BlobSkill extends Skill {
-    files: SkillSnapshotFile[];
-    snapshotHash: string;
-    repoPath: string;
-}
-declare const BLOB_ALLOWED_REPOS: Record<string, {
-    downloadUrl: (slug: string) => string;
-}>;
-declare function toSkillSlug(name: string): string;
-interface TreeEntry {
-    path: string;
-    type: 'blob' | 'tree';
-    sha: string;
-    size?: number;
-}
-interface RepoTree {
-    sha: string;
-    branch: string;
-    tree: TreeEntry[];
-}
-declare function resetRepoTreeAuthState(): void;
-declare function fetchRepoTree(ownerRepo: string, ref?: string, getToken?: () => string | null): Promise<RepoTree | null>;
-declare function getSkillFolderHashFromTree(tree: RepoTree, skillPath: string): string | null;
-declare function findSkillMdPaths(tree: RepoTree, subpath?: string): string[];
-interface BlobInstallResult {
-    skills: BlobSkill[];
-    tree: RepoTree;
-}
-declare function tryBlobInstall(ownerRepo: string, options?: {
-    subpath?: string;
-    skillFilter?: string;
-    ref?: string;
-    getToken?: () => string | null;
-    includeInternal?: boolean;
-}): Promise<BlobInstallResult | null>;
-
 interface InstallTelemetryData {
     event: 'install';
     source: string;
@@ -545,14 +705,47 @@ interface FindTelemetryData {
     query: string;
     resultCount: string;
     interactive?: '1';
+    mode?: 'local' | 'remote';
 }
-interface SyncTelemetryData {
-    event: 'experimental_sync';
-    skillCount: string;
-    successCount: string;
-    agents: string;
+interface CacheCleanAllTelemetryData {
+    event: 'cache_clean_all';
+    cacheRoot?: string;
+}
+interface CacheCleanSourceTelemetryData {
+    event: 'cache_clean_source';
+    source: string;
+}
+interface CacheRemoveSourceTelemetryData {
+    event: 'cache_remove_source';
+    source: string;
+    removedSkills?: string;
+}
+interface StoreCleanTelemetryData {
+    event: 'store_clean';
+}
+interface StoreCleanForceTelemetryData {
+    event: 'store_clean_force';
+}
+interface StoreUpdateTelemetryData {
+    event: 'store_update';
+    keyword?: string;
+    sourceCount?: string;
+    successCount?: string;
+    failCount?: string;
+}
+interface StoreRemoveTelemetryData {
+    event: 'store_remove';
+    source: string;
+    sourceType: string;
+    removedSkills?: string;
+}
+interface StoreRemoveForceTelemetryData {
+    event: 'store_remove_force';
+    source: string;
+    sourceType: string;
+    removedSkills?: string;
 }
-type TelemetryData = InstallTelemetryData | RemoveTelemetryData | UpdateTelemetryData | FindTelemetryData | SyncTelemetryData;
+type TelemetryData = InstallTelemetryData | RemoveTelemetryData | UpdateTelemetryData | FindTelemetryData | CacheCleanAllTelemetryData | CacheCleanSourceTelemetryData | CacheRemoveSourceTelemetryData | StoreCleanTelemetryData | StoreCleanForceTelemetryData | StoreUpdateTelemetryData | StoreRemoveTelemetryData | StoreRemoveForceTelemetryData;
 declare function setDetectedAgent(agentName: string | null): void;
 declare function setVersion(version: string): void;
 interface PartnerAudit {
@@ -595,18 +788,11 @@ declare function parseFrontmatter(raw: string): {
     content: string;
 };
 
-declare const I18n: {
-    readonly defaultLocale: "zh-CN";
-    readonly timeZone: "Asia/Shanghai";
-    readonly locales: string[];
-};
-type Locale = (typeof I18n)['locales'][number];
-
 interface SkillsCliDeps {
     version?: string;
     cwd?: string;
     inAgent?: boolean;
-    locale?: Locale;
+    locale?: Lang;
 }
 interface SkillsCliResult {
     code: number;
@@ -645,4 +831,59 @@ declare function getXdgState(): string;
 declare function getXdgCache(): string;
 declare function getProjectDirectory(): string;
 
-export { AGENTS_DIR, type AddOptions, type AgentConfig, type AgentProcess, type AgentSpawn, type AgentType, type AuditResponse, BLOB_ALLOWED_REPOS, type BlobInstallResult, type BlobSkill, DEFAULT_CLONE_TIMEOUT, type DiscoverSkillsOptions, type DismissedPrompts, EVE_SUBAGENTS_DIR, type FindOptions, GitCloneError, type HostProvider, type InstallMode, type InstalledSkill, type LocalSkillLockEntry, type LocalSkillLockFile, type MaterializedUseSkill, type ParseFindOptionsResult, type ParseUseOptionsResult, type ParsedSource, type PartnerAudit, type ProviderMatch, type ProviderRegistry, type RemoteSkill as ProviderRemoteSkill, type RemoteSkill$1 as RemoteSkill, type RemoveOptions, type RepoTree, SKILLS_SUBDIR, type SearchSkill, type Skill, type SkillAuditData, type SkillDownloadResponse, type SkillLockEntry, type SkillLockFile, type SkillSnapshotFile, type SkillsAgentAdapter, type SkillsCliDeps, type SkillsCliResult, type SyncOptions, type TreeEntry, UNIVERSAL_SKILLS_DIR, type UpdateCheckOptions, type UpdateScope, type UseOptions, type UseSkill, type WellKnownFileContent, type WellKnownIndex, type WellKnownIndexV1, type WellKnownIndexV2, WellKnownProvider, type WellKnownSkill, type WellKnownSkillEntry, type WellKnownSkillEntryV1, type WellKnownSkillEntryV2, addSkillToLocalLock, addSkillToLock, agents, buildUsePrompt, cleanupTempDir, cloneRepo, computeContentHash, computeSkillFolderHash, detectAgent, detectInstalledAgents, discoverSkills, dismissPrompt, fetchAuditData, fetchRepoTree, fetchSkillFolderHash, filterSkills, findProvider, findSkillMdPaths, flushTelemetry, getAgentAdapter, getAgentBaseDir, getAgentConfig, getAgentName, getAgentType, getAllLockedSkills, getCanonicalPath, getCanonicalSkillsDir, getEveSubagentSkillsDir, getEveSubagents, getGitHubToken, getGlobal, getHomeDir, getInstallPath, getInstance, getLastSelectedAgents, getLocalLockPath, getNonUniversalAgents, getOpenClawGlobalSkillsDir, getOwnerRepo, getProjectDirectory, getProviders, getSkillDisplayName, getSkillFolderHashFromTree, getSkillFromLock, getSkillLockPath, getSkillsBySource, getUniversalAgents, getVisibleUniversalAgents, getXdgCache, getXdgConfig, getXdgData, getXdgState, handleSkillsCli, hasAgentAdapter, hasProjectSkills, initTelemetry, installBlobSkillForAgent, installRemoteSkillForAgent, installSkillForAgent, installWellKnownSkillForAgent, isGitHubHttpsCloneUrl, isGitHubSsoAuthError, isPromptDismissed, isRepoPrivate, isRunningInAgent, isSkillInstalled, isSubpathSafe, isUniversalAgent, launchAgentInteractively, listInstalledSkills, matchesSkillFilter, materializeUseSkill, parseAddOptions, parseFindOptions, parseFrontmatter, parseGitHubRepoUrl, parseListOptions, parseOwnerRepo, parseRemoveOptions, parseSkillMd, parseSource, parseSyncOptions, parseUpdateOptions, parseUseOptions, readLocalLock, readSkillLock, registerProvider, registry, removeCommand, removeSkillFromLocalLock, removeSkillFromLock, renderBanner, renderHelp, requireAgentAdapter, resetGhAuthWarning, resetGlobalAdapter, resetInstanceAdapter, resetRepoTreeAuthState, resolveUpdateScope, runAdd, runFind, runInstallFromLock, runList, runSync, runUpdate, runUse, sanitizeMetadata, sanitizeName, sanitizeSubpath, saveSelectedAgents, searchSkillsAPI, setAgentAdapter, setDetectedAgent, setGlobalAdapter, setInstanceAdapter, setVersion, shouldInstallInternalSkills, stripTerminalEscapes, toSkillSlug, track, tryBlobInstall, wellKnownProvider, writeLocalLock, writeSkillLock };
+interface SkillDefinition {
+    name: string;
+    description: string;
+    scope?: 'general' | 'coder' | 'all';
+}
+type PluginSourceCategory = 'builtin' | 'project' | 'global' | 'marketplace' | 'well-known' | 'git' | 'file' | 'local';
+interface PluginSourceEntry {
+    id: string;
+    name: string;
+    description?: string;
+    location: string;
+    category: PluginSourceCategory;
+    metadata?: Record<string, unknown>;
+}
+interface PluginSourceLoadResult {
+    skills: SkillDefinition[];
+    version?: string;
+    author?: {
+        name: string;
+        email?: string;
+    };
+}
+interface PluginSource {
+    readonly id: string;
+    readonly category: PluginSourceCategory;
+    fetch(): Promise<PluginSourceEntry[]>;
+    load(entry: PluginSourceEntry): Promise<PluginSourceLoadResult>;
+}
+
+interface WellKnownSourceOptions {
+    url: string;
+    id?: string;
+    displayName?: string;
+}
+declare function createWellKnownSource(opts: WellKnownSourceOptions): PluginSource;
+
+interface LocalPluginSourceOptions {
+    basePath: string;
+    id?: string;
+    displayName?: string;
+}
+declare function createLocalPluginSource(opts: LocalPluginSourceOptions): PluginSource;
+
+declare function registerSource(source: PluginSource): void;
+declare function listSources(): PluginSource[];
+declare function findSource(id: string): PluginSource | null;
+declare function findSourcesByCategory(category: PluginSourceCategory): PluginSource[];
+declare function listAllEntries(): Promise<Array<{
+    sourceId: string;
+    entries: PluginSourceEntry[];
+} | {
+    sourceId: string;
+    error: Error;
+}>>;
+
+export { AGENTS_DIR, type AddOptions, type AgentConfig, type AgentInstallMatrix, type AgentProcess, type AgentSkillDirsResult, type AgentSpawn, type AgentType, type AuditResponse, BLOB_ALLOWED_REPOS, type BlobInstallResult, type BlobSkill, type CellAction, type CellScope, DEFAULT_CLONE_TIMEOUT, type DiscoverSkillsOptions, type DismissedPrompts, EVE_SUBAGENTS_DIR, type FindOptions, GitCloneError, type HostProvider, type InstallCell, type InstallMode, type InstallScope, type InstallState, type InstalledSkill, type LocalPluginSourceOptions, type LocalSkillLockEntry, type LocalSkillLockFile, type MaterializedUseSkill, PROJECT_SKILLS_DIR_PATTERN, type ParseFindOptionsResult, type ParseUseOptionsResult, type ParsedSource, type PartnerAudit, type PluginSource, type PluginSourceCategory, type PluginSourceEntry, type PluginSourceLoadResult, type PostInstallInput, type PostInstallResult, type ProviderMatch, type ProviderRegistry, type RemoteSkill as ProviderRemoteSkill, type RemoteSkill$1 as RemoteSkill, type RemoveOptions, type RepoTree, SKILLS_SUBDIR, type SearchSkill, type Skill, type SkillAuditData, type SkillDownloadResponse, type SkillLockEntry, type SkillLockFile, type SkillSnapshotFile, type SkillsAgentAdapter, type SkillsCliDeps, type SkillsCliResult, type StoreOptions, type TreeEntry, UNIVERSAL_SKILLS_DIR, type UniversalScope, type UpdateCheckOptions, type UpdateScope, type UseOptions, type UseSkill, type WellKnownFileContent, type WellKnownIndex, type WellKnownIndexV1, type WellKnownIndexV2, WellKnownProvider, type WellKnownSkill, type WellKnownSkillEntry, type WellKnownSkillEntryV1, type WellKnownSkillEntryV2, type WellKnownSourceOptions, acquireSourceClone, addSkillToLocalLock, addSkillToLock, agents, applyActions, buildMatrix, buildUsePrompt, cleanCache, cleanCachedRepo, cleanupTempDir, cloneRepo, computeContentHash, computeSkillFolderHash, createLocalPluginSource, createWellKnownSource, detectAgent, detectInstalledAgents, discoverSkills, dismissPrompt, ensureCachedSource, fetchAuditData, fetchRepoTree, fetchSkillFolderHash, filterSkills, findProvider, findSkillMdPaths, findSource, findSourcesByCategory, flushTelemetry, getAgentAdapter, getAgentBaseDir, getAgentConfig, getAgentGlobalSkillDirs, getAgentName, getAgentProjectSkillContainerPrefixes, getAgentProjectSkillDirs, getAgentSkillDirs, getAgentType, getAllLockedSkills, getCacheRepoDir, getCacheRoot, getCanonicalPath, getCanonicalSkillsDir, getEveSubagentSkillsDir, getEveSubagents, getGitHubToken, getGlobal, getHomeDir, getInstallPath, getInstance, getLocalLockPath, getNonUniversalAgents, getOpenClawGlobalSkillsDir, getOwnerRepo, getProjectDirectory, getProviders, getSkillDisplayName, getSkillFolderHashFromTree, getSkillFromLock, getSkillLockPath, getSkillsBySource, getSourceDir, getUniversalAgents, getXdgCache, getXdgConfig, getXdgData, getXdgState, handleSkillsCli, hasAgentAdapter, hasProjectSkills, initTelemetry, installBlobSkillForAgent, installFromCache, installRemoteSkillForAgent, installSkillForAgent, installWellKnownSkillForAgent, isGitHubHttpsCloneUrl, isGitHubSsoAuthError, isPromptDismissed, isRepoPrivate, isRunningInAgent, isSkillInstalled, isSubpathSafe, isUniversalAgent, launchAgentInteractively, listAllEntries, listInstalledSkills, listSources, matchesSkillFilter, matchesUniversalScope, materializeUseSkill, parseAddOptions, parseFindOptions, parseFrontmatter, parseGitHubRepoUrl, parseListOptions, parseOwnerRepo, parseRemoveOptions, parseSkillMd, parseSource, parseStoreOptions, parseUpdateOptions, parseUseOptions, planActions, probeCell, readLocalLock, readSkillLock, registerProvider, registerSource, registry, removeCommand, removeSkillFromLocalLock, removeSkillFromLock, renderBanner, renderHelp, requireAgentAdapter, resetGhAuthWarning, resetGlobalAdapter, resetInstanceAdapter, resetRepoTreeAuthState, resolveUpdateScope, runAdd, runDoctor, runFind, runList, runPostInstallReconcile, runStore, runStoreClean, runStoreList, runStoreRemove, runStoreUpdate, runUpdate, runUse, sanitizeMetadata, sanitizeName, sanitizeSubpath, searchSkillsAPI, setAgentAdapter, setDetectedAgent, setGlobalAdapter, setInstanceAdapter, setVersion, shouldInstallInternalSkills, stripTerminalEscapes, toSkillSlug, track, tryBlobInstall, wellKnownProvider, writeLocalLock, writeSkillLock };

package/dist/index.mjs

@@ -1 +1 @@
-export{Y as AGENTS_DIR,f as DEFAULT_CLONE_TIMEOUT,S as EVE_SUBAGENTS_DIR,g as GitCloneError,Z as SKILLS_SUBDIR,_ as UNIVERSAL_SKILLS_DIR,ya as WellKnownProvider,q as addSkillToLocalLock,Ha as addSkillToLock,P as agents,hb as buildUsePrompt,l as cleanupTempDir,k as cloneRepo,Da as computeContentHash,p as computeSkillFolderHash,qa as detectAgent,Q as detectInstalledAgents,v as discoverSkills,Na as dismissPrompt,na as fetchAuditData,Ga as fetchSkillFolderHash,x as filterSkills,wa as findProvider,pa as flushTelemetry,F as getAgentAdapter,ca as getAgentBaseDir,R as getAgentConfig,sa as getAgentName,ta as getAgentType,Ka as getAllLockedSkills,ga as getCanonicalPath,aa as getCanonicalSkillsDir,ba as getEveSubagentSkillsDir,T as getEveSubagents,Fa as getGitHubToken,A as getGlobal,I as getHomeDir,fa as getInstallPath,D as getInstance,Oa as getLastSelectedAgents,m as getLocalLockPath,W as getNonUniversalAgents,O as getOpenClawGlobalSkillsDir,a as getOwnerRepo,N as getProjectDirectory,xa as getProviders,w as getSkillDisplayName,Ja as getSkillFromLock,Aa as getSkillLockPath,La as getSkillsBySource,U as getUniversalAgents,V as getVisibleUniversalAgents,M as getXdgCache,J as getXdgConfig,K as getXdgData,L as getXdgState,nb as handleSkillsCli,G as hasAgentAdapter,cb as hasProjectSkills,Qa as initTelemetry,ja as installBlobSkillForAgent,ha as installRemoteSkillForAgent,da as installSkillForAgent,ia as installWellKnownSkillForAgent,i as isGitHubHttpsCloneUrl,j as isGitHubSsoAuthError,Ma as isPromptDismissed,c as isRepoPrivate,ra as isRunningInAgent,ea as isSkillInstalled,u as isSubpathSafe,X as isUniversalAgent,kb as launchAgentInteractively,ka as listInstalledSkills,eb as matchesSkillFilter,ib as materializeUseSkill,Sa as parseAddOptions,Ta as parseFindOptions,h as parseGitHubRepoUrl,Za as parseListOptions,b as parseOwnerRepo,ab as parseRemoveOptions,t as parseSkillMd,e as parseSource,Xa as parseSyncOptions,bb as parseUpdateOptions,gb as parseUseOptions,n as readLocalLock,Ba as readSkillLock,va as registerProvider,ua as registry,$a as removeCommand,r as removeSkillFromLocalLock,Ia as removeSkillFromLock,lb as renderBanner,mb as renderHelp,H as requireAgentAdapter,Ea as resetGhAuthWarning,z as resetGlobalAdapter,C as resetInstanceAdapter,db as resolveUpdateScope,Ra as runAdd,Va as runFind,Ya as runInstallFromLock,_a as runList,Wa as runSync,fb as runUpdate,jb as runUse,$ as sanitizeName,d as sanitizeSubpath,Pa as saveSelectedAgents,Ua as searchSkillsAPI,E as setAgentAdapter,la as setDetectedAgent,y as setGlobalAdapter,B as setInstanceAdapter,ma as setVersion,s as shouldInstallInternalSkills,oa as track,za as wellKnownProvider,o as writeLocalLock,Ca as writeSkillLock}from'./chunks/chunk-645XWVJB.mjs';export{e as BLOB_ALLOWED_REPOS,h as fetchRepoTree,j as findSkillMdPaths,i as getSkillFolderHashFromTree,d as parseFrontmatter,g as resetRepoTreeAuthState,c as sanitizeMetadata,b as stripTerminalEscapes,f as toSkillSlug,k as tryBlobInstall}from'./chunks/chunk-ZEMGS5WR.mjs';
+export{c as applyActions,d as buildMatrix,G as buildUsePrompt,f as detectAgent,h as getAgentName,i as getAgentType,M as handleSkillsCli,k as hasProjectSkills,o as initTelemetry,g as isRunningInAgent,J as launchAgentInteractively,m as matchesSkillFilter,H as materializeUseSkill,q as parseAddOptions,x as parseFindOptions,A as parseListOptions,D as parseRemoveOptions,r as parseStoreOptions,j as parseUpdateOptions,F as parseUseOptions,b as planActions,a as probeCell,C as removeCommand,K as renderBanner,L as renderHelp,l as resolveUpdateScope,p as runAdd,E as runDoctor,z as runFind,B as runList,e as runPostInstallReconcile,s as runStore,u as runStoreClean,t as runStoreList,w as runStoreRemove,v as runStoreUpdate,n as runUpdate,I as runUse,y as searchSkillsAPI}from'./chunks/chunk-GR2NJUJ6.mjs';export{c as fetchAuditData,e as flushTelemetry,a as setDetectedAgent,b as setVersion,d as track}from'./chunks/chunk-CFMOYU7R.mjs';export{i as addSkillToLock,e as computeContentHash,p as dismissPrompt,h as fetchSkillFolderHash,l as getAllLockedSkills,g as getGitHubToken,k as getSkillFromLock,b as getSkillLockPath,m as getSkillsBySource,n as isPromptDismissed,c as readSkillLock,j as removeSkillFromLock,f as resetGhAuthWarning,d as writeSkillLock}from'./chunks/chunk-4R6NKPNW.mjs';import'./chunks/chunk-72DXY4B7.mjs';export{a as AGENTS_DIR,b as SKILLS_SUBDIR,c as UNIVERSAL_SKILLS_DIR,g as getAgentBaseDir,o as getCanonicalPath,e as getCanonicalSkillsDir,f as getEveSubagentSkillsDir,m as getInstallPath,r as installBlobSkillForAgent,p as installRemoteSkillForAgent,h as installSkillForAgent,q as installWellKnownSkillForAgent,k as isSkillInstalled,s as listInstalledSkills,d as sanitizeName}from'./chunks/chunk-676OG55M.mjs';import {n,B}from'./chunks/chunk-2YVJ7YP6.mjs';export{f as DEFAULT_CLONE_TIMEOUT,g as GitCloneError,m as WellKnownProvider,R as acquireSourceClone,w as addSkillToLocalLock,ka as cleanCache,ja as cleanCachedRepo,l as cleanupTempDir,k as cloneRepo,v as computeSkillFolderHash,B as discoverSkills,da as ensureCachedSource,D as filterSkills,Q as getCacheRepoDir,O as getCacheRoot,r as getLocalLockPath,a as getOwnerRepo,C as getSkillDisplayName,J as getSourceDir,ia as installFromCache,i as isGitHubHttpsCloneUrl,j as isGitHubSsoAuthError,c as isRepoPrivate,A as isSubpathSafe,h as parseGitHubRepoUrl,b as parseOwnerRepo,z as parseSkillMd,e as parseSource,t as readLocalLock,x as removeSkillFromLocalLock,d as sanitizeSubpath,y as shouldInstallInternalSkills,n as wellKnownProvider,u as writeLocalLock}from'./chunks/chunk-2YVJ7YP6.mjs';export{w as BLOB_ALLOWED_REPOS,h as EVE_SUBAGENTS_DIR,m as PROJECT_SKILLS_DIR_PATTERN,e as agents,f as detectInstalledAgents,A as fetchRepoTree,C as findSkillMdPaths,g as getAgentConfig,o as getAgentGlobalSkillDirs,q as getAgentProjectSkillContainerPrefixes,n as getAgentProjectSkillDirs,p as getAgentSkillDirs,i as getEveSubagents,l as getNonUniversalAgents,d as getOpenClawGlobalSkillsDir,B as getSkillFolderHashFromTree,k as getUniversalAgents,r as isUniversalAgent,j as matchesUniversalScope,c as parseFrontmatter,z as resetRepoTreeAuthState,b as sanitizeMetadata,a as stripTerminalEscapes,y as toSkillSlug,D as tryBlobInstall}from'./chunks/chunk-6PJ3YQA7.mjs';export{h as getAgentAdapter,c as getGlobal,k as getHomeDir,f as getInstance,p as getProjectDirectory,o as getXdgCache,l as getXdgConfig,m as getXdgData,n as getXdgState,i as hasAgentAdapter,j as requireAgentAdapter,b as resetGlobalAdapter,e as resetInstanceAdapter,g as setAgentAdapter,a as setGlobalAdapter,d as setInstanceAdapter}from'./chunks/chunk-RWZ4LFSN.mjs';import {b}from'./chunks/chunk-WQGSYA5D.mjs';import {join}from'path';var d=class{constructor(){b(this,"providers",[]);}register(o){if(this.providers.some(t=>t.id===o.id))throw new Error(`Provider with id "${o.id}" already registered`);this.providers.push(o);}findProvider(o){for(let t of this.providers)if(t.match(o).matches)return t;return null}getProviders(){return [...this.providers]}},p=new d;function at(e){p.register(e);}function ct(e){return p.findProvider(e)}function ut(){return p.getProviders()}var u=new Map;function k(e){if(u.has(e.id))throw new Error(`PluginSource with id "${e.id}" already registered`);u.set(e.id,e);}function S(){return Array.from(u.values()).map(e=>e)}function P(e){return u.get(e)??null}function y(e){return Array.from(u.values()).filter(o=>o.category===e)}async function x(){let e=S();return await Promise.all(e.map(async t=>{try{let r=await t.fetch();return {sourceId:t.id,entries:r}}catch(r){return {sourceId:t.id,error:r instanceof Error?r:new Error(String(r))}}}))}function pt(e){return {name:e.name,description:e.description,scope:"all"}}function h(e){return {id:e.id??`well-known:${new URL(e.url).hostname}`,category:"well-known",async fetch(){return (await n.fetchAllSkills(e.url)).map(r=>({id:r.name,name:r.name,description:r.description,location:r.sourceUrl,category:"well-known",metadata:{installName:r.installName,sourceIdentifier:n.getSourceIdentifier(e.url),sourceUrl:r.sourceUrl}}))},async load(t){let l=(await n.fetchAllSkills(e.url)).find(n=>n.name===t.id);if(!l)throw new Error(`Skill "${t.id}" not found in well-known source ${e.url}`);return {skills:[pt(l)],version:"well-known",author:{name:new URL(e.url).hostname}}}}}async function A(e){try{let t=await(await import('fs/promises')).readFile(e,"utf-8");return JSON.parse(t)}catch{return null}}function w(e){let o=e.basePath.split(/[\\/]/).filter(Boolean).pop()??"local";return {id:e.id??`local:${o}`,category:"file",async fetch(){let r=[],l=await A(join(e.basePath,".claude-plugin/plugin.json"));l?.name&&r.push({id:l.name,name:l.name,description:l.description,location:e.basePath,category:"file",metadata:{skills:l.skills,manifest:"plugin.json"}});let n=await A(join(e.basePath,".claude-plugin/marketplace.json"));if(n?.plugins)for(let i of n.plugins)i.name&&(typeof i.source!="string"&&i.source!==void 0||r.push({id:i.name,name:i.name,description:i.description,location:i.source?join(e.basePath,n.metadata?.pluginRoot??"",i.source):e.basePath,category:"file",metadata:{skills:i.skills,manifest:"marketplace.json",pluginRoot:n.metadata?.pluginRoot}}));return r},async load(r){return {skills:(await B(r.location)).map(i=>({name:i.name,description:i.description,scope:"all"})),version:"local",author:{name:o}}}}}export{w as createLocalPluginSource,h as createWellKnownSource,ct as findProvider,P as findSource,y as findSourcesByCategory,ut as getProviders,x as listAllEntries,S as listSources,at as registerProvider,k as registerSource,p as registry};