🌊 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
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
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.tsnew file mode 100644index 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)+ );+}