@cloudpftc/opencode-orchestrator 3.5.15

package/v3/@claude-flow/cli/dist/src/plugins/store/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * 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/v3/@claude-flow/cli/dist/src/plugins/store/index.js

@@ -0,0 +1,141 @@
+/**
+ * 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/v3/@claude-flow/cli/dist/src/plugins/store/search.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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/v3/@claude-flow/cli/dist/src/plugins/store/search.js

@@ -0,0 +1,230 @@
+/**
+ * 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