@revealui/ai 0.1.0

package/dist/skills/activation/skill-activator.js

@@ -0,0 +1,224 @@
+/**
+ * Skill Activator
+ *
+ * Determines which skills to activate based on context.
+ */
+import { generateEmbedding } from '../../embeddings/index.js';
+/**
+ * Cosine similarity between two vectors.
+ */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        return 0;
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        const aVal = a[i] ?? 0;
+        const bVal = b[i] ?? 0;
+        dotProduct += aVal * bVal;
+        normA += aVal * aVal;
+        normB += bVal * bVal;
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    return magnitude === 0 ? 0 : dotProduct / magnitude;
+}
+/**
+ * Skill activator for context-based skill activation.
+ */
+export class SkillActivator {
+    registry;
+    semanticThreshold;
+    maxAutoActivate;
+    enableSemantic;
+    constructor(config) {
+        this.registry = config.registry;
+        this.semanticThreshold = config.semanticThreshold ?? 0.7;
+        this.maxAutoActivate = config.maxAutoActivate ?? 3;
+        this.enableSemantic = config.enableSemantic ?? true;
+    }
+    /**
+     * Activate skills based on context.
+     *
+     * Activation methods (in priority order):
+     * 1. Explicit: /skill-name syntax
+     * 2. Semantic: Embedding similarity match
+     * 3. File-match: Based on current file types
+     * 4. Project-type: Based on project configuration
+     */
+    async activate(context) {
+        const activatedSkills = [];
+        const activationReasons = {};
+        // 1. Handle explicit skill requests (/skill-name)
+        if (context.explicitSkills?.length) {
+            for (const name of context.explicitSkills) {
+                const skill = await this.registry.loadSkill(name);
+                if (skill) {
+                    activatedSkills.push(skill);
+                    activationReasons[name] = {
+                        type: 'explicit',
+                        reason: `Explicitly requested via /${name}`,
+                    };
+                }
+            }
+        }
+        // 2. Semantic activation based on task description
+        if (this.enableSemantic && context.taskDescription) {
+            const semanticMatches = await this.findSemanticMatches(context.taskDescription, activatedSkills.map((s) => s.metadata.name));
+            for (const match of semanticMatches.slice(0, this.maxAutoActivate)) {
+                if (!activationReasons[match.skill.metadata.name]) {
+                    activatedSkills.push(match.skill);
+                    activationReasons[match.skill.metadata.name] = {
+                        type: 'semantic',
+                        score: match.score,
+                        reason: `Matched task description with ${(match.score * 100).toFixed(1)}% similarity`,
+                    };
+                }
+            }
+        }
+        // 3. File-type based activation
+        if (context.currentFiles?.length) {
+            const fileMatches = this.findFileTypeMatches(context.currentFiles, activatedSkills.map((s) => s.metadata.name));
+            for (const match of fileMatches) {
+                if (!activationReasons[match.skill.metadata.name]) {
+                    activatedSkills.push(match.skill);
+                    activationReasons[match.skill.metadata.name] = {
+                        type: 'file-match',
+                        reason: `Matched file pattern: ${match.pattern}`,
+                    };
+                }
+            }
+        }
+        // 4. Project-type based activation
+        if (context.projectType) {
+            const projectMatches = this.findProjectTypeMatches(context.projectType, activatedSkills.map((s) => s.metadata.name));
+            for (const match of projectMatches) {
+                if (!activationReasons[match.skill.metadata.name]) {
+                    activatedSkills.push(match.skill);
+                    activationReasons[match.skill.metadata.name] = {
+                        type: 'project-type',
+                        reason: `Matched project type: ${context.projectType}`,
+                    };
+                }
+            }
+        }
+        return { activatedSkills, activationReasons };
+    }
+    /**
+     * Find skills by semantic similarity to a query.
+     */
+    async findSemanticMatches(query, excludeNames) {
+        const queryEmbedding = await generateEmbedding(query);
+        const skills = this.registry.getAll();
+        const matches = [];
+        for (const skill of skills) {
+            if (excludeNames.includes(skill.metadata.name))
+                continue;
+            // Generate embedding if not present
+            if (!skill.embedding) {
+                const textForEmbedding = `${skill.metadata.name}: ${skill.metadata.description}\n${skill.instructions.slice(0, 500)}`;
+                const result = await generateEmbedding(textForEmbedding);
+                skill.embedding = result.vector;
+            }
+            const score = cosineSimilarity(queryEmbedding.vector, skill.embedding);
+            if (score >= this.semanticThreshold) {
+                matches.push({ skill, score });
+            }
+        }
+        return matches.sort((a, b) => b.score - a.score);
+    }
+    /**
+     * Find skills that match file types.
+     */
+    findFileTypeMatches(files, excludeNames) {
+        const skills = this.registry.getAll();
+        const matches = [];
+        // Extract file extensions
+        const extensions = new Set(files
+            .map((f) => {
+            const ext = f.split('.').pop()?.toLowerCase();
+            return ext ? `.${ext}` : '';
+        })
+            .filter(Boolean));
+        // Map extensions to skill tags
+        const extensionToTags = {
+            '.ts': ['typescript', 'node', 'frontend', 'backend'],
+            '.tsx': ['typescript', 'react', 'frontend'],
+            '.js': ['javascript', 'node', 'frontend', 'backend'],
+            '.jsx': ['javascript', 'react', 'frontend'],
+            '.py': ['python', 'backend', 'ml', 'data'],
+            '.rs': ['rust', 'backend', 'systems'],
+            '.go': ['golang', 'backend'],
+            '.sql': ['database', 'sql'],
+            '.css': ['css', 'frontend', 'styling'],
+            '.scss': ['sass', 'css', 'frontend', 'styling'],
+            '.md': ['documentation', 'markdown'],
+        };
+        const relevantTags = new Set();
+        for (const ext of extensions) {
+            const tags = extensionToTags[ext];
+            if (tags) {
+                for (const t of tags) {
+                    relevantTags.add(t);
+                }
+            }
+        }
+        for (const skill of skills) {
+            if (excludeNames.includes(skill.metadata.name))
+                continue;
+            const skillTags = skill.metadata.tags ?? [];
+            const matchingTags = skillTags.filter((t) => relevantTags.has(t.toLowerCase()));
+            if (matchingTags.length > 0) {
+                matches.push({
+                    skill,
+                    pattern: matchingTags.join(', '),
+                });
+            }
+        }
+        return matches;
+    }
+    /**
+     * Find skills that match project type.
+     */
+    findProjectTypeMatches(projectType, excludeNames) {
+        const skills = this.registry.getAll();
+        const matches = [];
+        const projectTypeLower = projectType.toLowerCase();
+        for (const skill of skills) {
+            if (excludeNames.includes(skill.metadata.name))
+                continue;
+            const tags = skill.metadata.tags ?? [];
+            const description = skill.metadata.description.toLowerCase();
+            const name = skill.metadata.name.toLowerCase();
+            if (tags.some((t) => t.toLowerCase().includes(projectTypeLower)) ||
+                description.includes(projectTypeLower) ||
+                name.includes(projectTypeLower)) {
+                matches.push({ skill });
+            }
+        }
+        return matches;
+    }
+    /**
+     * Parse explicit skill references from user input.
+     *
+     * @example
+     * parseExplicitSkills("Please /react-best-practices fix this component")
+     * // ["react-best-practices"]
+     */
+    static parseExplicitSkills(input) {
+        const matches = input.match(/\/([a-z0-9-]+)/g);
+        if (!matches)
+            return [];
+        return matches.map((m) => m.slice(1)); // Remove leading slash
+    }
+    /**
+     * Get all available skills for auto-completion.
+     */
+    getAvailableSkills() {
+        return this.registry.getAllMetadata().map((m) => ({
+            name: m.name,
+            description: m.description,
+        }));
+    }
+}

package/dist/skills/catalog/catalog-search.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Vercel Catalog Search
+ *
+ * Search the skills.sh catalog for skills.
+ */
+import type { VercelCatalogSkill, VercelSkillSearchResult } from './catalog-types.js';
+import { type CatalogConfig } from './vercel-catalog.js';
+/**
+ * Search options.
+ */
+export interface SearchOptions extends CatalogConfig {
+    /** Minimum relevance score (0-1) */
+    threshold?: number;
+    /** Maximum results to return */
+    limit?: number;
+    /** Filter by tags */
+    tags?: string[];
+    /** Filter by compatibility */
+    compatibility?: string[];
+}
+/**
+ * Search the Vercel Skills catalog.
+ *
+ * Performs keyword-based search across skill names, descriptions, and tags.
+ *
+ * @param query - Search query
+ * @param options - Search options
+ * @returns Matching skills sorted by relevance
+ */
+export declare function searchVercelCatalog(query: string, options?: SearchOptions): Promise<VercelSkillSearchResult[]>;
+/**
+ * Get skills by tag.
+ *
+ * @param tag - Tag to filter by
+ * @param options - Catalog options
+ * @returns Skills with the specified tag
+ */
+export declare function getSkillsByTag(tag: string, options?: CatalogConfig): Promise<VercelCatalogSkill[]>;
+/**
+ * Get skills by compatibility.
+ *
+ * @param compatibility - Compatibility to filter by (e.g., "claude-code")
+ * @param options - Catalog options
+ * @returns Skills compatible with the specified tool
+ */
+export declare function getSkillsByCompatibility(compatibility: string, options?: CatalogConfig): Promise<VercelCatalogSkill[]>;
+/**
+ * Get a specific skill by ID.
+ *
+ * @param id - Skill ID (e.g., "vercel-labs/agent-skills/react-best-practices")
+ * @param options - Catalog options
+ * @returns Skill if found, undefined otherwise
+ */
+export declare function getSkillById(id: string, options?: CatalogConfig): Promise<VercelCatalogSkill | undefined>;
+//# sourceMappingURL=catalog-search.d.ts.map

package/dist/skills/catalog/catalog-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-search.d.ts","sourceRoot":"","sources":["../../../src/skills/catalog/catalog-search.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA;AACrF,OAAO,EAAE,KAAK,aAAa,EAAsB,MAAM,qBAAqB,CAAA;AAE5E;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,aAAa;IAClD,oCAAoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd,qBAAqB;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IAEf,8BAA8B;IAC9B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,uBAAuB,EAAE,CAAC,CA8EpC;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAK/B;AAED;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAS/B;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAGzC"}

package/dist/skills/catalog/catalog-search.js

@@ -0,0 +1,111 @@
+/**
+ * Vercel Catalog Search
+ *
+ * Search the skills.sh catalog for skills.
+ */
+import { fetchVercelCatalog } from './vercel-catalog.js';
+/**
+ * Search the Vercel Skills catalog.
+ *
+ * Performs keyword-based search across skill names, descriptions, and tags.
+ *
+ * @param query - Search query
+ * @param options - Search options
+ * @returns Matching skills sorted by relevance
+ */
+export async function searchVercelCatalog(query, options = {}) {
+    const catalog = await fetchVercelCatalog(options);
+    const queryLower = query.toLowerCase();
+    const results = [];
+    for (const skill of catalog.skills) {
+        let score = 0;
+        const matchReasons = [];
+        // Check name (highest weight)
+        if (skill.name.toLowerCase().includes(queryLower)) {
+            score += 10;
+            matchReasons.push('name match');
+        }
+        // Check description (medium weight)
+        if (skill.description.toLowerCase().includes(queryLower)) {
+            score += 5;
+            matchReasons.push('description match');
+        }
+        // Check tags (medium weight)
+        if (skill.tags?.some((tag) => tag.toLowerCase().includes(queryLower))) {
+            score += 3;
+            matchReasons.push('tag match');
+        }
+        // Check owner/repo (low weight)
+        if (skill.owner.toLowerCase().includes(queryLower) ||
+            skill.repo.toLowerCase().includes(queryLower)) {
+            score += 1;
+            matchReasons.push('owner/repo match');
+        }
+        // Apply tag filter
+        if (options.tags && options.tags.length > 0) {
+            const hasTag = options.tags.some((tag) => skill.tags?.some((skillTag) => skillTag.toLowerCase() === tag.toLowerCase()));
+            if (!hasTag) {
+                continue;
+            }
+        }
+        // Apply compatibility filter
+        if (options.compatibility && options.compatibility.length > 0) {
+            const hasCompat = options.compatibility.some((compat) => skill.compatibility?.some((skillCompat) => skillCompat.toLowerCase() === compat.toLowerCase()));
+            if (!hasCompat) {
+                continue;
+            }
+        }
+        // Normalize score to 0-1 range
+        const normalizedScore = Math.min(score / 10, 1);
+        // Apply threshold
+        const threshold = options.threshold ?? 0.1;
+        if (normalizedScore >= threshold && score > 0) {
+            results.push({
+                skill,
+                score: normalizedScore,
+                matchReason: matchReasons.join(', '),
+            });
+        }
+    }
+    // Sort by score descending
+    results.sort((a, b) => b.score - a.score);
+    // Apply limit
+    const limit = options.limit ?? 10;
+    return results.slice(0, limit);
+}
+/**
+ * Get skills by tag.
+ *
+ * @param tag - Tag to filter by
+ * @param options - Catalog options
+ * @returns Skills with the specified tag
+ */
+export async function getSkillsByTag(tag, options = {}) {
+    const catalog = await fetchVercelCatalog(options);
+    const tagLower = tag.toLowerCase();
+    return catalog.skills.filter((skill) => skill.tags?.some((t) => t.toLowerCase() === tagLower));
+}
+/**
+ * Get skills by compatibility.
+ *
+ * @param compatibility - Compatibility to filter by (e.g., "claude-code")
+ * @param options - Catalog options
+ * @returns Skills compatible with the specified tool
+ */
+export async function getSkillsByCompatibility(compatibility, options = {}) {
+    const catalog = await fetchVercelCatalog(options);
+    const compatLower = compatibility.toLowerCase();
+    return catalog.skills.filter((skill) => skill.compatibility?.some((c) => c.toLowerCase() === compatLower) ||
+        skill.compatibility?.includes('universal'));
+}
+/**
+ * Get a specific skill by ID.
+ *
+ * @param id - Skill ID (e.g., "vercel-labs/agent-skills/react-best-practices")
+ * @param options - Catalog options
+ * @returns Skill if found, undefined otherwise
+ */
+export async function getSkillById(id, options = {}) {
+    const catalog = await fetchVercelCatalog(options);
+    return catalog.skills.find((skill) => skill.id === id);
+}

package/dist/skills/catalog/catalog-types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Vercel Skills Catalog Types
+ *
+ * Type definitions for the skills.sh catalog API.
+ */
+import { z } from 'zod/v4';
+/**
+ * A skill entry in the Vercel catalog.
+ */
+export declare const VercelCatalogSkillSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    owner: z.ZodString;
+    repo: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    installs: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    compatibility: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    stars: z.ZodOptional<z.ZodNumber>;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type VercelCatalogSkill = z.infer<typeof VercelCatalogSkillSchema>;
+/**
+ * Search result from the catalog.
+ */
+export declare const VercelSkillSearchResultSchema: z.ZodObject<{
+    skill: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        owner: z.ZodString;
+        repo: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+        installs: z.ZodOptional<z.ZodNumber>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        compatibility: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+        stars: z.ZodOptional<z.ZodNumber>;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    score: z.ZodNumber;
+    matchReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type VercelSkillSearchResult = z.infer<typeof VercelSkillSearchResultSchema>;
+/**
+ * Catalog metadata.
+ */
+export declare const CatalogMetadataSchema: z.ZodObject<{
+    totalSkills: z.ZodNumber;
+    fetchedAt: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CatalogMetadata = z.infer<typeof CatalogMetadataSchema>;
+/**
+ * Full catalog with metadata.
+ */
+export declare const VercelCatalogSchema: z.ZodObject<{
+    metadata: z.ZodObject<{
+        totalSkills: z.ZodNumber;
+        fetchedAt: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    skills: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        owner: z.ZodString;
+        repo: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+        installs: z.ZodOptional<z.ZodNumber>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        compatibility: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+        stars: z.ZodOptional<z.ZodNumber>;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VercelCatalog = z.infer<typeof VercelCatalogSchema>;
+//# sourceMappingURL=catalog-types.d.ts.map

package/dist/skills/catalog/catalog-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-types.d.ts","sourceRoot":"","sources":["../../../src/skills/catalog/catalog-types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;iBAoCnC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;iBASxC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;iBAShC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAM9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/skills/catalog/catalog-types.js

@@ -0,0 +1,66 @@
+/**
+ * Vercel Skills Catalog Types
+ *
+ * Type definitions for the skills.sh catalog API.
+ */
+import { z } from 'zod/v4';
+/**
+ * A skill entry in the Vercel catalog.
+ */
+export const VercelCatalogSkillSchema = z.object({
+    /** Unique skill identifier (e.g., "vercel-labs/agent-skills/react-best-practices") */
+    id: z.string(),
+    /** Skill name */
+    name: z.string(),
+    /** Owner/organization */
+    owner: z.string(),
+    /** Repository name */
+    repo: z.string(),
+    /** Path within repo (if monorepo) */
+    path: z.string().optional(),
+    /** Description */
+    description: z.string(),
+    /** Installation count */
+    installs: z.number().optional(),
+    /** Tags/categories */
+    tags: z.array(z.string()).optional(),
+    /** Compatible tools/frameworks */
+    compatibility: z.array(z.string()).optional(),
+    /** Last updated timestamp */
+    updatedAt: z.string().optional(),
+    /** GitHub stars */
+    stars: z.number().optional(),
+    /** Version */
+    version: z.string().optional(),
+});
+/**
+ * Search result from the catalog.
+ */
+export const VercelSkillSearchResultSchema = z.object({
+    /** Matching skill */
+    skill: VercelCatalogSkillSchema,
+    /** Relevance score (0-1) */
+    score: z.number().min(0).max(1),
+    /** Why this skill matched */
+    matchReason: z.string().optional(),
+});
+/**
+ * Catalog metadata.
+ */
+export const CatalogMetadataSchema = z.object({
+    /** Total number of skills */
+    totalSkills: z.number(),
+    /** When catalog was last fetched */
+    fetchedAt: z.string().datetime(),
+    /** Catalog version */
+    version: z.string().optional(),
+});
+/**
+ * Full catalog with metadata.
+ */
+export const VercelCatalogSchema = z.object({
+    /** Catalog metadata */
+    metadata: CatalogMetadataSchema,
+    /** All skills in the catalog */
+    skills: z.array(VercelCatalogSkillSchema),
+});

package/dist/skills/catalog/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Vercel Skills Catalog
+ *
+ * Discovery and search for skills in the Vercel Skills ecosystem (skills.sh).
+ */
+export { getSkillById, getSkillsByCompatibility, getSkillsByTag, type SearchOptions, searchVercelCatalog, } from './catalog-search.js';
+export type { CatalogMetadata, VercelCatalog, VercelCatalogSkill, VercelSkillSearchResult, } from './catalog-types.js';
+export { type CatalogConfig, clearCatalogCache, fetchVercelCatalog, getTrendingSkills, } from './vercel-catalog.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/skills/catalog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/skills/catalog/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,YAAY,EACZ,wBAAwB,EACxB,cAAc,EACd,KAAK,aAAa,EAClB,mBAAmB,GACpB,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EACV,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,KAAK,aAAa,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,qBAAqB,CAAA"}

package/dist/skills/catalog/index.js

@@ -0,0 +1,7 @@
+/**
+ * Vercel Skills Catalog
+ *
+ * Discovery and search for skills in the Vercel Skills ecosystem (skills.sh).
+ */
+export { getSkillById, getSkillsByCompatibility, getSkillsByTag, searchVercelCatalog, } from './catalog-search.js';
+export { clearCatalogCache, fetchVercelCatalog, getTrendingSkills, } from './vercel-catalog.js';

package/dist/skills/catalog/vercel-catalog.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Vercel Skills Catalog
+ *
+ * Fetch and cache the skills.sh catalog for discovery.
+ */
+import type { VercelCatalog, VercelCatalogSkill } from './catalog-types.js';
+/**
+ * Configuration for catalog fetching.
+ */
+export interface CatalogConfig {
+    /** Cache directory (default: ~/.revealui/cache) */
+    cacheDir?: string;
+    /** Cache TTL in milliseconds (default: 24 hours) */
+    cacheTtl?: number;
+    /** Force refresh even if cache is valid */
+    forceRefresh?: boolean;
+}
+/**
+ * Fetch the Vercel Skills catalog.
+ *
+ * This function fetches the catalog from skills.sh (or a known GitHub source)
+ * and caches it locally. The cache is invalidated after 24 hours by default.
+ *
+ * @param config - Configuration options
+ * @returns The catalog of available skills
+ */
+export declare function fetchVercelCatalog(config?: CatalogConfig): Promise<VercelCatalog>;
+/**
+ * Get trending skills from the catalog (sorted by installs).
+ *
+ * @param limit - Maximum number of skills to return
+ * @param config - Catalog configuration
+ * @returns Trending skills
+ */
+export declare function getTrendingSkills(limit?: number, config?: CatalogConfig): Promise<VercelCatalogSkill[]>;
+/**
+ * Clear the catalog cache.
+ *
+ * @param cacheDir - Cache directory
+ */
+export declare function clearCatalogCache(cacheDir?: string): void;
+//# sourceMappingURL=vercel-catalog.d.ts.map

package/dist/skills/catalog/vercel-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel-catalog.d.ts","sourceRoot":"","sources":["../../../src/skills/catalog/vercel-catalog.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAmB,aAAa,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAE5F;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAiBD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,GAAE,aAAkB,GAAG,OAAO,CAAC,aAAa,CAAC,CAgC3F;AAiHD;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,SAAK,EACV,MAAM,GAAE,aAAkB,GACzB,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAO/B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAKzD"}