@claude-flow/cli 3.32.2 → 3.32.3

package/dist/src/plugins/store/index.d.ts

@@ -1,76 +0,0 @@
-/**
- * Plugin Store Module
- * Decentralized plugin marketplace using IPFS
- *
- * Provides:
- * - Plugin discovery via IPNS
- * - Search with filters
- * - Download with verification
- * - Publish with signing
- */
-export * from './types.js';
-export { PluginDiscoveryService, createPluginDiscoveryService, DEFAULT_PLUGIN_STORE_CONFIG, type PluginDiscoveryResult, } from './discovery.js';
-export { searchPlugins, getPluginSearchSuggestions, getPluginTagCloud, getPluginCategoryStats, findSimilarPlugins, getFeaturedPlugins, getTrendingPlugins, getNewestPlugins, getOfficialPlugins, getPluginsByPermission, } from './search.js';
-import type { PluginRegistry, PluginEntry, PluginSearchOptions, PluginSearchResult, PluginStoreConfig } from './types.js';
-import { PluginDiscoveryService } from './discovery.js';
-/**
- * High-level Plugin Store API
- */
-export declare class PluginStore {
-    private discovery;
-    private registry;
-    constructor(config?: Partial<PluginStoreConfig>);
-    /**
-     * Initialize the store by discovering the registry
-     */
-    initialize(registryName?: string): Promise<boolean>;
-    /**
-     * Check if store is initialized
-     */
-    isInitialized(): boolean;
-    /**
-     * Get the current registry
-     */
-    getRegistry(): PluginRegistry | null;
-    /**
-     * Search plugins
-     */
-    search(options?: PluginSearchOptions): PluginSearchResult;
-    /**
-     * Get a plugin by ID
-     */
-    getPlugin(pluginId: string): PluginEntry | undefined;
-    /**
-     * Get similar plugins
-     */
-    getSimilarPlugins(pluginId: string, limit?: number): PluginEntry[];
-    /**
-     * Get featured plugins
-     */
-    getFeatured(): PluginEntry[];
-    /**
-     * Get official plugins
-     */
-    getOfficial(): PluginEntry[];
-    /**
-     * Get trending plugins
-     */
-    getTrending(): PluginEntry[];
-    /**
-     * Get newest plugins
-     */
-    getNewest(): PluginEntry[];
-    /**
-     * Get discovery service
-     */
-    getDiscovery(): PluginDiscoveryService;
-    /**
-     * Refresh registry
-     */
-    refresh(registryName?: string): Promise<boolean>;
-}
-/**
- * Create a new plugin store instance
- */
-export declare function createPluginStore(config?: Partial<PluginStoreConfig>): PluginStore;
-//# sourceMappingURL=index.d.ts.map

package/dist/src/plugins/store/index.js

@@ -1,141 +0,0 @@
-/**
- * Plugin Store Module
- * Decentralized plugin marketplace using IPFS
- *
- * Provides:
- * - Plugin discovery via IPNS
- * - Search with filters
- * - Download with verification
- * - Publish with signing
- */
-// Re-export types
-export * from './types.js';
-// Re-export discovery
-export { PluginDiscoveryService, createPluginDiscoveryService, DEFAULT_PLUGIN_STORE_CONFIG, } from './discovery.js';
-// Re-export search
-export { searchPlugins, getPluginSearchSuggestions, getPluginTagCloud, getPluginCategoryStats, findSimilarPlugins, getFeaturedPlugins, getTrendingPlugins, getNewestPlugins, getOfficialPlugins, getPluginsByPermission, } from './search.js';
-import { PluginDiscoveryService } from './discovery.js';
-import { searchPlugins, findSimilarPlugins } from './search.js';
-/**
- * High-level Plugin Store API
- */
-export class PluginStore {
-    discovery;
-    registry = null;
-    constructor(config) {
-        this.discovery = new PluginDiscoveryService(config);
-    }
-    /**
-     * Initialize the store by discovering the registry
-     */
-    async initialize(registryName) {
-        const result = await this.discovery.discoverRegistry(registryName);
-        if (result.success && result.registry) {
-            this.registry = result.registry;
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Check if store is initialized
-     */
-    isInitialized() {
-        return this.registry !== null;
-    }
-    /**
-     * Get the current registry
-     */
-    getRegistry() {
-        return this.registry;
-    }
-    /**
-     * Search plugins
-     */
-    search(options = {}) {
-        if (!this.registry) {
-            return {
-                plugins: [],
-                total: 0,
-                page: 1,
-                pageSize: options.limit || 20,
-                hasMore: false,
-                query: options,
-            };
-        }
-        return searchPlugins(this.registry, options);
-    }
-    /**
-     * Get a plugin by ID
-     */
-    getPlugin(pluginId) {
-        return this.registry?.plugins.find(p => p.id === pluginId);
-    }
-    /**
-     * Get similar plugins
-     */
-    getSimilarPlugins(pluginId, limit = 5) {
-        if (!this.registry)
-            return [];
-        return findSimilarPlugins(this.registry, pluginId, limit);
-    }
-    /**
-     * Get featured plugins
-     */
-    getFeatured() {
-        if (!this.registry)
-            return [];
-        return this.registry.featured
-            .map(id => this.registry.plugins.find(p => p.id === id))
-            .filter((p) => p !== undefined);
-    }
-    /**
-     * Get official plugins
-     */
-    getOfficial() {
-        if (!this.registry)
-            return [];
-        return this.registry.official
-            .map(id => this.registry.plugins.find(p => p.id === id))
-            .filter((p) => p !== undefined);
-    }
-    /**
-     * Get trending plugins
-     */
-    getTrending() {
-        if (!this.registry)
-            return [];
-        return this.registry.trending
-            .map(id => this.registry.plugins.find(p => p.id === id))
-            .filter((p) => p !== undefined);
-    }
-    /**
-     * Get newest plugins
-     */
-    getNewest() {
-        if (!this.registry)
-            return [];
-        return this.registry.newest
-            .map(id => this.registry.plugins.find(p => p.id === id))
-            .filter((p) => p !== undefined);
-    }
-    /**
-     * Get discovery service
-     */
-    getDiscovery() {
-        return this.discovery;
-    }
-    /**
-     * Refresh registry
-     */
-    async refresh(registryName) {
-        this.discovery.clearCache();
-        return this.initialize(registryName);
-    }
-}
-/**
- * Create a new plugin store instance
- */
-export function createPluginStore(config) {
-    return new PluginStore(config);
-}
-//# sourceMappingURL=index.js.map

package/dist/src/plugins/store/search.d.ts

@@ -1,46 +0,0 @@
-/**
- * Plugin Search Service
- * Search and filter plugins from the registry
- */
-import type { PluginEntry, PluginRegistry, PluginSearchOptions, PluginSearchResult } from './types.js';
-/**
- * Search plugins in the registry
- */
-export declare function searchPlugins(registry: PluginRegistry, options?: PluginSearchOptions): PluginSearchResult;
-/**
- * Get search suggestions based on partial query
- */
-export declare function getPluginSearchSuggestions(registry: PluginRegistry, partialQuery: string, limit?: number): string[];
-/**
- * Get tag cloud with counts
- */
-export declare function getPluginTagCloud(registry: PluginRegistry): Map<string, number>;
-/**
- * Get category statistics
- */
-export declare function getPluginCategoryStats(registry: PluginRegistry): Map<string, number>;
-/**
- * Find similar plugins based on tags and category
- */
-export declare function findSimilarPlugins(registry: PluginRegistry, pluginId: string, limit?: number): PluginEntry[];
-/**
- * Get featured plugins
- */
-export declare function getFeaturedPlugins(registry: PluginRegistry): PluginEntry[];
-/**
- * Get trending plugins
- */
-export declare function getTrendingPlugins(registry: PluginRegistry): PluginEntry[];
-/**
- * Get newest plugins
- */
-export declare function getNewestPlugins(registry: PluginRegistry): PluginEntry[];
-/**
- * Get official plugins
- */
-export declare function getOfficialPlugins(registry: PluginRegistry): PluginEntry[];
-/**
- * Get plugins by permission
- */
-export declare function getPluginsByPermission(registry: PluginRegistry, permission: string): PluginEntry[];
-//# sourceMappingURL=search.d.ts.map

package/dist/src/plugins/store/search.js

@@ -1,230 +0,0 @@
-/**
- * Plugin Search Service
- * Search and filter plugins from the registry
- */
-/**
- * Search plugins in the registry
- */
-export function searchPlugins(registry, options = {}) {
-    let plugins = [...registry.plugins];
-    // Text search (name, displayName, description, tags)
-    if (options.query) {
-        const query = options.query.toLowerCase();
-        plugins = plugins.filter(p => p.name?.toLowerCase().includes(query) ||
-            p.displayName?.toLowerCase().includes(query) ||
-            p.description?.toLowerCase().includes(query) ||
-            (p.tags || []).some(t => t.toLowerCase().includes(query)) ||
-            (p.keywords || []).some(k => k.toLowerCase().includes(query)));
-    }
-    // Category filter
-    if (options.category) {
-        plugins = plugins.filter(p => (p.categories || []).includes(options.category));
-    }
-    // Type filter
-    if (options.type) {
-        plugins = plugins.filter(p => p.type === options.type);
-    }
-    // Tags filter (match any)
-    if (options.tags && options.tags.length > 0) {
-        plugins = plugins.filter(p => options.tags.some(tag => (p.tags || []).includes(tag)));
-    }
-    // Author filter
-    if (options.author) {
-        plugins = plugins.filter(p => p.author.id === options.author ||
-            p.author.displayName?.toLowerCase().includes(options.author.toLowerCase()));
-    }
-    // Rating filter
-    if (options.minRating !== undefined) {
-        plugins = plugins.filter(p => p.rating >= options.minRating);
-    }
-    // Downloads filter
-    if (options.minDownloads !== undefined) {
-        plugins = plugins.filter(p => p.downloads >= options.minDownloads);
-    }
-    // Verified filter
-    if (options.verified !== undefined) {
-        plugins = plugins.filter(p => p.verified === options.verified);
-    }
-    // Trust level filter
-    if (options.trustLevel) {
-        const trustOrder = ['unverified', 'community', 'verified', 'official'];
-        const minIndex = trustOrder.indexOf(options.trustLevel);
-        plugins = plugins.filter(p => {
-            const pluginIndex = trustOrder.indexOf(p.trustLevel);
-            return pluginIndex >= minIndex;
-        });
-    }
-    // Permissions filter
-    if (options.permissions && options.permissions.length > 0) {
-        plugins = plugins.filter(p => options.permissions.every(perm => (p.permissions || []).includes(perm)));
-    }
-    // Security audit filter
-    if (options.hasSecurityAudit !== undefined) {
-        plugins = plugins.filter(p => options.hasSecurityAudit ? p.securityAudit !== undefined : true);
-    }
-    // Sort
-    const sortBy = options.sortBy || 'downloads';
-    const sortOrder = options.sortOrder || 'desc';
-    plugins.sort((a, b) => {
-        let comparison = 0;
-        switch (sortBy) {
-            case 'downloads':
-                comparison = a.downloads - b.downloads;
-                break;
-            case 'rating':
-                comparison = a.rating - b.rating;
-                break;
-            case 'newest':
-                comparison = new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
-                break;
-            case 'name':
-                comparison = a.name.localeCompare(b.name);
-                break;
-            case 'reputation':
-                comparison = a.author.reputation - b.author.reputation;
-                break;
-        }
-        return sortOrder === 'desc' ? -comparison : comparison;
-    });
-    // Pagination
-    const total = plugins.length;
-    const limit = options.limit || 20;
-    const offset = options.offset || 0;
-    const page = Math.floor(offset / limit) + 1;
-    plugins = plugins.slice(offset, offset + limit);
-    return {
-        plugins,
-        total,
-        page,
-        pageSize: limit,
-        hasMore: offset + limit < total,
-        query: options,
-    };
-}
-/**
- * Get search suggestions based on partial query
- */
-export function getPluginSearchSuggestions(registry, partialQuery, limit = 10) {
-    const query = partialQuery.toLowerCase();
-    const suggestions = new Set();
-    // Search in plugin names
-    for (const plugin of registry.plugins) {
-        if (plugin.name.toLowerCase().includes(query)) {
-            suggestions.add(plugin.name);
-        }
-        if (plugin.displayName.toLowerCase().includes(query)) {
-            suggestions.add(plugin.displayName);
-        }
-        // Search in tags
-        for (const tag of plugin.tags || []) {
-            if (tag.toLowerCase().includes(query)) {
-                suggestions.add(tag);
-            }
-        }
-        // Search in keywords
-        for (const keyword of plugin.keywords || []) {
-            if (keyword.toLowerCase().includes(query)) {
-                suggestions.add(keyword);
-            }
-        }
-    }
-    return Array.from(suggestions).slice(0, limit);
-}
-/**
- * Get tag cloud with counts
- */
-export function getPluginTagCloud(registry) {
-    const tagCounts = new Map();
-    for (const plugin of registry.plugins) {
-        for (const tag of plugin.tags || []) {
-            tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
-        }
-    }
-    // Sort by count descending
-    const sortedEntries = Array.from(tagCounts.entries()).sort((a, b) => b[1] - a[1]);
-    return new Map(sortedEntries);
-}
-/**
- * Get category statistics
- */
-export function getPluginCategoryStats(registry) {
-    const categoryCounts = new Map();
-    for (const plugin of registry.plugins) {
-        for (const category of plugin.categories || []) {
-            categoryCounts.set(category, (categoryCounts.get(category) || 0) + 1);
-        }
-    }
-    return categoryCounts;
-}
-/**
- * Find similar plugins based on tags and category
- */
-export function findSimilarPlugins(registry, pluginId, limit = 5) {
-    const targetPlugin = registry.plugins.find(p => p.id === pluginId);
-    if (!targetPlugin) {
-        return [];
-    }
-    // Score plugins by tag overlap and category match
-    const scored = registry.plugins
-        .filter(p => p.id !== pluginId)
-        .map(plugin => {
-        let score = 0;
-        // Tag overlap
-        const tagOverlap = (plugin.tags || []).filter(t => (targetPlugin.tags || []).includes(t)).length;
-        score += tagOverlap * 2;
-        // Category match
-        const categoryMatch = (plugin.categories || []).some(c => (targetPlugin.categories || []).includes(c));
-        if (categoryMatch)
-            score += 3;
-        // Type match
-        if (plugin.type === targetPlugin.type)
-            score += 2;
-        // Same author bonus
-        if (plugin.author.id === targetPlugin.author.id)
-            score += 1;
-        return { plugin, score };
-    })
-        .filter(s => s.score > 0)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, limit);
-    return scored.map(s => s.plugin);
-}
-/**
- * Get featured plugins
- */
-export function getFeaturedPlugins(registry) {
-    return registry.featured
-        .map(id => registry.plugins.find(p => p.id === id))
-        .filter((p) => p !== undefined);
-}
-/**
- * Get trending plugins
- */
-export function getTrendingPlugins(registry) {
-    return registry.trending
-        .map(id => registry.plugins.find(p => p.id === id))
-        .filter((p) => p !== undefined);
-}
-/**
- * Get newest plugins
- */
-export function getNewestPlugins(registry) {
-    return registry.newest
-        .map(id => registry.plugins.find(p => p.id === id))
-        .filter((p) => p !== undefined);
-}
-/**
- * Get official plugins
- */
-export function getOfficialPlugins(registry) {
-    return registry.official
-        .map(id => registry.plugins.find(p => p.id === id))
-        .filter((p) => p !== undefined);
-}
-/**
- * Get plugins by permission
- */
-export function getPluginsByPermission(registry, permission) {
-    return registry.plugins.filter(p => (p.permissions || []).includes(permission));
-}
-//# sourceMappingURL=search.js.map