Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

Checkpoint: File edits

rUvb447cf234434
diff --git a/v3/@claude-flow/cli/src/plugins/store/search.ts b/v3/@claude-flow/cli/src/plugins/store/search.ts
new file mode 100644
index 0000000000..e0cc80722e
--- /dev/null
+++ b/v3/@claude-flow/cli/src/plugins/store/search.ts
@@ -0,0 +1,305 @@
+/**
+ * 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 function searchPlugins(
+ registry: PluginRegistry,
+ options: PluginSearchOptions = {}
+): PluginSearchResult {
+ 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: PluginRegistry,
+ partialQuery: string,
+ limit: number = 10
+): string[] {
+ const query = partialQuery.toLowerCase();
+ const suggestions = new Set<string>();
+
+ // 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: PluginRegistry): Map<string, number> {
+ const tagCounts = new Map<string, number>();
+
+ for (const plugin of registry.plugins) {
+ for (const tag of plugin.tags) {
+ tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+ }
+ }
+
+ // Sort by count descending
+ return new Map(
+ [...tagCounts.entries()].sort((a, b) => b[1] - a[1])
+ );
+}
+
+/**
+ * Get category statistics
+ */
+export function getPluginCategoryStats(registry: PluginRegistry): Map<string, number> {
+ const categoryCounts = new Map<string, number>();
+
+ 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: PluginRegistry,
+ pluginId: string,
+ limit: number = 5
+): PluginEntry[] {
+ 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: PluginRegistry): PluginEntry[] {
+ return registry.featured
+ .map(id => registry.plugins.find(p => p.id === id))
+ .filter((p): p is PluginEntry => p !== undefined);
+}
+
+/**
+ * Get trending plugins
+ */
+export function getTrendingPlugins(registry: PluginRegistry): PluginEntry[] {
+ return registry.trending
+ .map(id => registry.plugins.find(p => p.id === id))
+ .filter((p): p is PluginEntry => p !== undefined);
+}
+
+/**
+ * Get newest plugins
+ */
+export function getNewestPlugins(registry: PluginRegistry): PluginEntry[] {
+ return registry.newest
+ .map(id => registry.plugins.find(p => p.id === id))
+ .filter((p): p is PluginEntry => p !== undefined);
+}
+
+/**
+ * Get official plugins
+ */
+export function getOfficialPlugins(registry: PluginRegistry): PluginEntry[] {
+ return registry.official
+ .map(id => registry.plugins.find(p => p.id === id))
+ .filter((p): p is PluginEntry => p !== undefined);
+}
+
+/**
+ * Get plugins by permission
+ */
+export function getPluginsByPermission(
+ registry: PluginRegistry,
+ permission: string
+): PluginEntry[] {
+ return registry.plugins.filter(p =>
+ p.permissions.includes(permission as any)
+ );
+}