aman-intelligence 0.1.0

package/dist/marketplace/github-search.js

@@ -0,0 +1,268 @@
+import { defaultSlugForName } from '../utils/slug.js';
+import { parsePublisherMetadata, isVerifiedPublisherSlug } from './metadata-validator.js';
+import { isCacheFresh, readMarketplaceCache, writeMarketplaceCache, } from './cache.js';
+const GITHUB_API = 'https://api.github.com';
+const REQUEST_TIMEOUT_MS = 10_000;
+const USER_AGENT = 'aman-cli-marketplace';
+class GitHubMarketplaceError extends Error {
+    rateLimited;
+    offline;
+    constructor(message, rateLimited = false, offline = false) {
+        super(message);
+        this.rateLimited = rateLimited;
+        this.offline = offline;
+        this.name = 'GitHubMarketplaceError';
+    }
+}
+async function fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        return await fetch(url, {
+            ...init,
+            signal: controller.signal,
+            headers: {
+                Accept: 'application/vnd.github+json',
+                'User-Agent': USER_AGENT,
+                ...(init?.headers ?? {}),
+            },
+        });
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            throw new GitHubMarketplaceError('GitHub request timed out (10s)', false, false);
+        }
+        throw new GitHubMarketplaceError('Network unavailable', false, true);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function buildSearchQuery(userQuery) {
+    const q = userQuery.trim();
+    if (!q)
+        return 'topic:aman-asset';
+    return `topic:aman-asset ${q}`;
+}
+async function searchRepositories(userQuery) {
+    const q = encodeURIComponent(buildSearchQuery(userQuery));
+    const url = `${GITHUB_API}/search/repositories?q=${q}&sort=stars&order=desc&per_page=30`;
+    const res = await fetchWithTimeout(url);
+    if (res.status === 403 || res.status === 429) {
+        const remaining = res.headers.get('x-ratelimit-remaining');
+        throw new GitHubMarketplaceError(`GitHub API rate limit exceeded${remaining !== null ? ` (${remaining} remaining)` : ''}. Try again later or use cached results.`, true, false);
+    }
+    if (!res.ok) {
+        throw new GitHubMarketplaceError(`GitHub search failed (${res.status})`, false, res.status >= 500);
+    }
+    const data = (await res.json());
+    return data.items ?? [];
+}
+async function listRepoDirectories(owner, repo, branch, typeFolder) {
+    const url = `${GITHUB_API}/repos/${owner}/${repo}/contents/${typeFolder}?ref=${encodeURIComponent(branch)}`;
+    const res = await fetchWithTimeout(url);
+    if (res.status === 404)
+        return [];
+    if (res.status === 403 || res.status === 429) {
+        throw new GitHubMarketplaceError('GitHub API rate limit exceeded while listing assets', true, false);
+    }
+    if (!res.ok)
+        return [];
+    const entries = (await res.json());
+    if (!Array.isArray(entries))
+        return [];
+    return entries.filter((e) => e.type === 'dir').map((e) => e.name);
+}
+async function fetchRawMetadata(owner, repo, branch, type, localName) {
+    const typeFolder = type === 'skill' ? 'skills' : type === 'prompt' ? 'prompts' : 'mcps';
+    const url = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${typeFolder}/${localName}/metadata.json`;
+    const res = await fetchWithTimeout(url);
+    if (res.status === 404)
+        return null;
+    if (res.status === 403 || res.status === 429) {
+        throw new GitHubMarketplaceError('GitHub rate limit exceeded while fetching metadata', true, false);
+    }
+    if (!res.ok)
+        return null;
+    try {
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+async function discoverAssetsInRepo(item) {
+    const [owner, repo] = item.full_name.split('/');
+    if (!owner || !repo)
+        return [];
+    const branch = item.default_branch || 'main';
+    const source = `github:${owner}/${repo}`;
+    const stars = item.stargazers_count ?? 0;
+    const assets = [];
+    const typeFolders = [
+        { type: 'skill', folder: 'skills' },
+        { type: 'prompt', folder: 'prompts' },
+        { type: 'mcp', folder: 'mcps' },
+    ];
+    for (const { type, folder } of typeFolders) {
+        let names;
+        try {
+            names = await listRepoDirectories(owner, repo, branch, folder);
+        }
+        catch {
+            continue;
+        }
+        for (const localName of names) {
+            try {
+                const raw = await fetchRawMetadata(owner, repo, branch, type, localName);
+                if (!raw)
+                    continue;
+                const fallbackSlug = defaultSlugForName(localName, owner);
+                const meta = parsePublisherMetadata(raw, type, localName, fallbackSlug, owner);
+                const checksum = meta.integrity?.checksum ??
+                    'sha256:0000000000000000000000000000000000000000000000000000000000000000';
+                assets.push({
+                    slug: meta.slug,
+                    type: meta.type,
+                    name: meta.name,
+                    localName: meta.name,
+                    description: meta.description || item.description || '',
+                    version: meta.version,
+                    author: meta.author,
+                    tags: meta.tags,
+                    stars,
+                    source,
+                    verified: isVerifiedPublisherSlug(meta.slug),
+                    owner,
+                    repo,
+                    defaultBranch: branch,
+                    contentPath: `${folder}/${localName}`,
+                    checksum,
+                    id: meta.id,
+                    updatedAt: meta.updatedAt,
+                });
+            }
+            catch {
+                // Skip invalid or rejected metadata
+            }
+        }
+    }
+    return assets;
+}
+function filterByType(assets, typeFilter) {
+    if (typeFilter === 'all')
+        return assets;
+    return assets.filter((a) => a.type === typeFilter);
+}
+function filterByQuery(assets, query) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return assets;
+    return assets.filter((a) => {
+        const haystack = [a.name, a.slug, a.description, a.author, ...(a.tags ?? [])]
+            .join(' ')
+            .toLowerCase();
+        return haystack.includes(q);
+    });
+}
+function sortAssets(assets, sort) {
+    const copy = [...assets];
+    if (sort === 'stars') {
+        return copy.sort((a, b) => b.stars - a.stars || a.name.localeCompare(b.name));
+    }
+    if (sort === 'recent') {
+        return copy.sort((a, b) => {
+            const ta = a.updatedAt ? Date.parse(a.updatedAt) : 0;
+            const tb = b.updatedAt ? Date.parse(b.updatedAt) : 0;
+            return tb - ta || b.stars - a.stars;
+        });
+    }
+    return copy.sort((a, b) => a.name.localeCompare(b.name));
+}
+function cacheAgeMinutes(ageMs) {
+    return Math.max(0, Math.round(ageMs / 60000));
+}
+/**
+ * Search GitHub for `topic:aman-asset` publisher repos and load validated metadata.
+ * Uses ~/.aman/cache/marketplace/ with 1h TTL; serves stale cache on rate limit/offline.
+ */
+export async function searchGitHubMarketplace(options) {
+    const query = options.query ?? '';
+    const typeFilter = options.typeFilter ?? 'all';
+    const sort = options.sort ?? 'stars';
+    const cached = await readMarketplaceCache(query, typeFilter);
+    const fresh = cached && isCacheFresh(cached.ageMs);
+    if (cached && fresh && !options.forceRefresh) {
+        return {
+            assets: sortAssets(filterByQuery(cached.assets, query), sort),
+            fromCache: true,
+            cacheAgeMinutes: cacheAgeMinutes(cached.ageMs),
+            rateLimited: false,
+            offline: false,
+        };
+    }
+    try {
+        const repos = await searchRepositories(query);
+        const all = [];
+        for (const repo of repos) {
+            const discovered = await discoverAssetsInRepo(repo);
+            all.push(...discovered);
+        }
+        const filtered = filterByQuery(filterByType(all, typeFilter), query);
+        const sorted = sortAssets(filtered, sort);
+        await writeMarketplaceCache(query, typeFilter, sorted);
+        return {
+            assets: sorted,
+            fromCache: false,
+            cacheAgeMinutes: 0,
+            rateLimited: false,
+            offline: false,
+        };
+    }
+    catch (err) {
+        const rateLimited = err instanceof GitHubMarketplaceError && err.rateLimited;
+        const offline = err instanceof GitHubMarketplaceError && err.offline;
+        if (cached) {
+            return {
+                assets: sortAssets(filterByQuery(cached.assets, query), sort),
+                fromCache: true,
+                cacheAgeMinutes: cacheAgeMinutes(cached.ageMs),
+                rateLimited,
+                offline,
+                message: err instanceof Error ? err.message : String(err),
+            };
+        }
+        return {
+            assets: [],
+            fromCache: false,
+            cacheAgeMinutes: null,
+            rateLimited,
+            offline,
+            message: offline || rateLimited
+                ? 'Marketplace unavailable (offline). No cached results.'
+                : err instanceof Error
+                    ? err.message
+                    : String(err),
+        };
+    }
+}
+const assetIndex = new Map();
+export function indexMarketplaceAssets(assets) {
+    for (const a of assets) {
+        assetIndex.set(a.slug.toLowerCase(), a);
+        assetIndex.set(a.name.toLowerCase(), a);
+        assetIndex.set(a.localName.toLowerCase(), a);
+    }
+}
+export function findMarketplaceAsset(ref) {
+    const key = ref.trim().toLowerCase();
+    return assetIndex.get(key);
+}
+export async function loadMarketplaceIndex(options) {
+    const result = await searchGitHubMarketplace({
+        query: options?.query ?? '',
+        typeFilter: options?.typeFilter ?? 'all',
+    });
+    indexMarketplaceAssets(result.assets);
+    return result;
+}

package/dist/marketplace/install-from-candidate.d.ts

@@ -0,0 +1,6 @@
+import { Scope } from '../types/index.js';
+import { InstallCandidate } from '../services/marketplace.service.js';
+export declare function installFromCandidate(candidate: InstallCandidate, scope: Scope): Promise<{
+    path: string;
+    checksum: string;
+}>;

package/dist/marketplace/install-from-candidate.js

@@ -0,0 +1,14 @@
+import { assetService } from '../services/asset.service.js';
+import { installMarketplaceAsset } from './install.js';
+export async function installFromCandidate(candidate, scope) {
+    if (candidate.marketplaceAsset) {
+        const result = await installMarketplaceAsset(candidate.marketplaceAsset, scope);
+        return { path: result.installPath, checksum: result.checksum };
+    }
+    await assetService.install(candidate.name, candidate.type, scope, candidate.sourcePath, candidate.source);
+    const rootLabel = scope === 'project' ? '.aman' : '~/.aman';
+    return {
+        path: `${rootLabel}/${candidate.type}s/${candidate.name}`,
+        checksum: candidate.checksum ?? '',
+    };
+}

package/dist/marketplace/install.d.ts

@@ -0,0 +1,15 @@
+import { Scope } from '../types/index.js';
+import { MarketplaceAsset } from './types.js';
+export interface MarketplaceInstallResult {
+    scope: Scope;
+    localName: string;
+    type: MarketplaceAsset['type'];
+    installPath: string;
+    source: string;
+    checksum: string;
+}
+/**
+ * Install a marketplace asset from its GitHub publisher repo (read-only clone + verify).
+ * Does not use registry adapters. Rolls back on checksum failure before lockfile update.
+ */
+export declare function installMarketplaceAsset(asset: MarketplaceAsset, scope: Scope): Promise<MarketplaceInstallResult>;

package/dist/marketplace/install.js

@@ -0,0 +1,54 @@
+import path from 'path';
+import { LOCAL_DIR } from '../config/paths.js';
+import { assetService } from '../services/asset.service.js';
+import { environmentService } from '../services/environment.service.js';
+import { githubService } from '../services/github.service.js';
+import { removeDir } from '../storage/filesystem.js';
+import { computeAssetChecksum } from '../utils/integrity.js';
+import { assetDir } from '../storage/asset-layout.js';
+function typeRootDir(scope, type) {
+    const root = scope === 'global' ? environmentService.getActiveEnvironmentDir() : LOCAL_DIR;
+    const folder = type === 'skill' ? 'skills' : type === 'prompt' ? 'prompts' : 'mcps';
+    return path.join(root, folder);
+}
+/**
+ * Install a marketplace asset from its GitHub publisher repo (read-only clone + verify).
+ * Does not use registry adapters. Rolls back on checksum failure before lockfile update.
+ */
+export async function installMarketplaceAsset(asset, scope) {
+    const repoRef = `${asset.owner}/${asset.repo}`;
+    let tempDir;
+    try {
+        tempDir = await githubService.import(repoRef);
+        const srcDir = path.join(tempDir, asset.contentPath);
+        const actualChecksum = await computeAssetChecksum(asset.type, srcDir);
+        if (asset.checksum && !asset.checksum.endsWith('0000000000000000000000000000000000')) {
+            if (actualChecksum !== asset.checksum) {
+                throw new Error(`Checksum mismatch for ${asset.slug}: expected ${asset.checksum}, got ${actualChecksum}`);
+            }
+        }
+        await assetService.install(asset.localName, asset.type, scope, srcDir, asset.source, {
+            slug: asset.slug,
+            version: asset.version,
+            author: asset.author,
+            description: asset.description,
+            tags: asset.tags,
+            id: asset.id,
+            originalName: asset.localName,
+        });
+        const installPath = assetDir(asset.type, typeRootDir(scope, asset.type), asset.localName);
+        return {
+            scope,
+            localName: asset.localName,
+            type: asset.type,
+            installPath,
+            source: asset.source,
+            checksum: actualChecksum,
+        };
+    }
+    finally {
+        if (tempDir) {
+            await removeDir(tempDir).catch(() => { });
+        }
+    }
+}

package/dist/marketplace/metadata-validator.d.ts

@@ -0,0 +1,8 @@
+import { AssetMetadata } from '../types/asset-metadata.js';
+import { AssetType } from '../types/index.js';
+export declare function isVerifiedPublisherSlug(slug: string): boolean;
+/**
+ * Parse and validate metadata.json from a GitHub publisher repo.
+ * Ignores metadata.trust.verified — only @aman/ namespace is verified.
+ */
+export declare function parsePublisherMetadata(raw: unknown, fallbackType: AssetType, fallbackLocalName: string, fallbackSlug: string, fallbackAuthor: string): AssetMetadata;

package/dist/marketplace/metadata-validator.js

@@ -0,0 +1,79 @@
+import { normalizeAssetMetadata } from '../types/asset-metadata.js';
+/** Top-level keys allowed in publisher metadata.json (unknown keys are rejected). */
+const ALLOWED_METADATA_KEYS = new Set([
+    'schemaVersion',
+    'id',
+    'slug',
+    'type',
+    'name',
+    'description',
+    'version',
+    'author',
+    'tags',
+    'scope',
+    'visibility',
+    'createdAt',
+    'updatedAt',
+    'integrity',
+    'dependencies',
+    'trust',
+    'deprecated',
+    'source',
+    'installedAt',
+    'originalName',
+    'originalSlug',
+    // Legacy / publisher extras that are inert for the CLI
+    'abstract',
+    'category',
+    'organization',
+    'date',
+    'installs',
+    'rating',
+]);
+/** Keys that must never appear in external metadata (install-time execution risk). */
+const FORBIDDEN_METADATA_KEYS = new Set([
+    'scripts',
+    'hooks',
+    'install',
+    'postInstall',
+    'preInstall',
+    'bin',
+    'main',
+    'exports',
+]);
+export function isVerifiedPublisherSlug(slug) {
+    return slug.startsWith('@aman/');
+}
+/**
+ * Parse and validate metadata.json from a GitHub publisher repo.
+ * Ignores metadata.trust.verified — only @aman/ namespace is verified.
+ */
+export function parsePublisherMetadata(raw, fallbackType, fallbackLocalName, fallbackSlug, fallbackAuthor) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error('metadata.json must be a JSON object');
+    }
+    const record = raw;
+    for (const key of Object.keys(record)) {
+        if (FORBIDDEN_METADATA_KEYS.has(key)) {
+            throw new Error(`Rejected metadata field "${key}" (not permitted in marketplace assets)`);
+        }
+        if (!ALLOWED_METADATA_KEYS.has(key)) {
+            throw new Error(`Unexpected metadata field "${key}"`);
+        }
+    }
+    const typeRaw = record.type;
+    const type = typeRaw === 'skill' || typeRaw === 'prompt' || typeRaw === 'mcp' ? typeRaw : fallbackType;
+    const localName = typeof record.name === 'string' && record.name.trim().length > 0
+        ? record.name.trim()
+        : fallbackLocalName;
+    const slug = typeof record.slug === 'string' && record.slug.trim().length > 0 ? record.slug.trim() : fallbackSlug;
+    const meta = normalizeAssetMetadata(record, type, localName);
+    meta.slug = slug;
+    meta.type = type;
+    meta.name = localName;
+    meta.author = typeof record.author === 'string' ? record.author : fallbackAuthor;
+    if (meta.trust) {
+        meta.trust.verified = isVerifiedPublisherSlug(meta.slug);
+    }
+    return meta;
+}

package/dist/marketplace/types.d.ts

@@ -0,0 +1,34 @@
+import { AssetType } from '../types/index.js';
+/** Asset discovered from GitHub topic `aman-asset` publisher repositories. */
+export interface MarketplaceAsset {
+    slug: string;
+    type: AssetType;
+    name: string;
+    localName: string;
+    description: string;
+    version: string;
+    author: string;
+    tags: string[];
+    stars: number;
+    /** Provenance ref written to lockfile: `github:owner/repo` */
+    source: string;
+    verified: boolean;
+    owner: string;
+    repo: string;
+    defaultBranch: string;
+    /** Relative path inside repo, e.g. `skills/my-skill` */
+    contentPath: string;
+    checksum: string;
+    id?: string;
+    updatedAt?: string;
+}
+export interface MarketplaceSearchResult {
+    assets: MarketplaceAsset[];
+    fromCache: boolean;
+    cacheAgeMinutes: number | null;
+    rateLimited: boolean;
+    offline: boolean;
+    message?: string;
+}
+export type MarketplaceSort = 'stars' | 'recent' | 'name';
+export type MarketplaceTypeFilter = 'all' | AssetType;

package/dist/marketplace/types.js

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

package/dist/providers/local.provider.d.ts

@@ -0,0 +1,9 @@
+import { AssetProvider } from './provider.interface.js';
+import { AssetType, ProviderResult } from '../types/index.js';
+export declare class LocalProvider implements AssetProvider {
+    name: string;
+    search(query: string, type?: AssetType): Promise<ProviderResult[]>;
+    fetch(name: string, type: AssetType): Promise<string>;
+    available(): Promise<boolean>;
+}
+export declare const localProvider: LocalProvider;

package/dist/providers/local.provider.js

@@ -0,0 +1,51 @@
+import { assetService } from '../services/asset.service.js';
+import { assetListCategory, assetListDescription, assetListInstalls, assetListOrganization, assetListRating, assetListTags, assetListUpdated, assetListVersion, } from '../utils/asset-list-fields.js';
+import Fuse from 'fuse.js';
+export class LocalProvider {
+    name = 'local';
+    async search(query, type) {
+        const results = [];
+        const types = type ? [type] : ['skill', 'prompt', 'mcp'];
+        for (const t of types) {
+            const items = await assetService.list(t);
+            for (const item of items) {
+                results.push({
+                    type: t,
+                    name: item.name,
+                    source: item.source || this.name,
+                    sources: [item.source || this.name],
+                    description: assetListDescription(item),
+                    tags: assetListTags(item),
+                    category: assetListCategory(item),
+                    installs: assetListInstalls(item),
+                    rating: assetListRating(item),
+                    updated: assetListUpdated(item),
+                    version: assetListVersion(item),
+                    organization: assetListOrganization(item),
+                    installed: item.source === 'installed',
+                    confidence: 1.0,
+                });
+            }
+        }
+        if (!query) {
+            return results;
+        }
+        const fuse = new Fuse(results, {
+            keys: ['name', 'description'],
+            threshold: 0.3,
+        });
+        return fuse.search(query).map((r) => r.item);
+    }
+    async fetch(name, type) {
+        const items = await assetService.list(type);
+        const item = items.find((i) => i.name === name);
+        if (!item) {
+            throw new Error(`Asset not found in local provider: ${name}`);
+        }
+        return item.path;
+    }
+    async available() {
+        return true;
+    }
+}
+export const localProvider = new LocalProvider();

package/dist/providers/provider.interface.d.ts

@@ -0,0 +1,7 @@
+import { AssetType, ProviderResult } from '../types/index.js';
+export interface AssetProvider {
+    name: string;
+    search(query: string, type?: AssetType): Promise<ProviderResult[]>;
+    fetch(name: string, type: AssetType): Promise<string>;
+    available(): Promise<boolean>;
+}

package/dist/providers/provider.interface.js

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

package/dist/providers/registry.provider.d.ts

@@ -0,0 +1,2 @@
+import { AssetProvider } from './provider.interface.js';
+export declare const registryProvider: AssetProvider;

package/dist/providers/registry.provider.js

@@ -0,0 +1,42 @@
+import { registryService } from '../registry/registry.service.js';
+import { localNameFromSlug } from '../utils/slug.js';
+export const registryProvider = {
+    name: 'registry',
+    async available() {
+        return registryService.getAdapter().available();
+    },
+    async search(query, type) {
+        const result = await registryService.search({
+            query,
+            filters: type ? { type, includeDeprecated: true } : { includeDeprecated: true },
+        });
+        return result.hits.map((hit) => ({
+            name: localNameFromSlug(hit.slug),
+            type: hit.record.type,
+            source: 'registry',
+            sources: ['registry'],
+            description: hit.record.description,
+            tags: hit.record.tags,
+            version: hit.latestVersion,
+            organization: hit.record.trust.publisher ?? undefined,
+            installs: hit.record.trust.downloads,
+            rating: hit.record.trust.rating ?? undefined,
+            confidence: hit.record.trust.verified ? 1 : 0.5,
+            installed: false,
+            slug: hit.slug,
+        }));
+    },
+    async fetch(name, type) {
+        const slug = name.startsWith('@') ? name : `@aman/${name}`;
+        const listed = await registryService.list({ slug });
+        const match = listed.versions.find((v) => v.type === type);
+        if (!match) {
+            throw new Error(`Registry asset not found: ${slug} (${type})`);
+        }
+        const resolved = await registryService.resolve({ slug, version: match.version });
+        if (resolved.content.kind !== 'filesystem') {
+            throw new Error('Registry provider requires filesystem content');
+        }
+        return resolved.content.path;
+    },
+};

package/dist/providers/skills-sh.provider.d.ts

@@ -0,0 +1,11 @@
+import { AssetProvider } from './provider.interface.js';
+import { AssetType, ProviderResult } from '../types/index.js';
+export declare class SkillsShProvider implements AssetProvider {
+    name: string;
+    private bundledSkillsCache;
+    private getBundledSkills;
+    search(query: string, type?: AssetType): Promise<ProviderResult[]>;
+    fetch(name: string, type: AssetType): Promise<string>;
+    available(): Promise<boolean>;
+}
+export declare const skillsShProvider: SkillsShProvider;

package/dist/providers/skills-sh.provider.js

@@ -0,0 +1,56 @@
+import Fuse from 'fuse.js';
+import { BUNDLED_SKILLS } from '../config/paths.js';
+import { scanSkills } from '../storage/scanner.js';
+export class SkillsShProvider {
+    name = 'skills.sh';
+    bundledSkillsCache = null;
+    async getBundledSkills() {
+        if (!this.bundledSkillsCache) {
+            this.bundledSkillsCache = await scanSkills(BUNDLED_SKILLS, this.name);
+        }
+        return this.bundledSkillsCache;
+    }
+    async search(query, type) {
+        if (type && type !== 'skill')
+            return [];
+        const skills = await this.getBundledSkills();
+        const results = skills.map((skill) => ({
+            type: 'skill',
+            name: skill.name,
+            source: this.name,
+            sources: [this.name],
+            description: skill.description,
+            tags: skill.tags,
+            category: skill.category,
+            installs: skill.installs,
+            rating: skill.rating,
+            updated: skill.updated,
+            version: skill.version,
+            organization: skill.organization,
+            installed: false,
+            confidence: 1,
+        }));
+        if (!query.trim())
+            return results;
+        const fuse = new Fuse(results, {
+            keys: ['name', 'description'],
+            threshold: 0.3,
+        });
+        return fuse.search(query).map((result) => result.item);
+    }
+    async fetch(name, type) {
+        if (type !== 'skill') {
+            throw new Error('skills.sh currently provides skills only.');
+        }
+        const skills = await this.getBundledSkills();
+        const skill = skills.find((item) => item.name === name);
+        if (!skill) {
+            throw new Error(`Skill not found on skills.sh: ${name}`);
+        }
+        return skill.path;
+    }
+    async available() {
+        return true;
+    }
+}
+export const skillsShProvider = new SkillsShProvider();