@claude-flow/cli 3.32.3 → 3.32.4

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

@@ -0,0 +1,232 @@
+/**
+ * Pattern Search Service
+ * Search and filter patterns from decentralized registry
+ */
+/**
+ * Search patterns in registry
+ */
+export function searchPatterns(registry, options = {}) {
+    let patterns = [...registry.patterns];
+    // Text search
+    if (options.query) {
+        const query = options.query.toLowerCase();
+        patterns = patterns.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)));
+    }
+    // Category filter
+    if (options.category) {
+        patterns = patterns.filter(p => p.categories.includes(options.category));
+    }
+    // Language filter
+    if (options.language) {
+        patterns = patterns.filter(p => p.language === options.language);
+    }
+    // Framework filter
+    if (options.framework) {
+        patterns = patterns.filter(p => p.framework === options.framework);
+    }
+    // Tags filter
+    if (options.tags && options.tags.length > 0) {
+        patterns = patterns.filter(p => options.tags.some(t => p.tags.includes(t)));
+    }
+    // Author filter
+    if (options.author) {
+        patterns = patterns.filter(p => p.author.id === options.author);
+    }
+    // Rating filter
+    if (options.minRating !== undefined) {
+        patterns = patterns.filter(p => p.rating >= options.minRating);
+    }
+    // Downloads filter
+    if (options.minDownloads !== undefined) {
+        patterns = patterns.filter(p => p.downloads >= options.minDownloads);
+    }
+    // Verified filter
+    if (options.verified !== undefined) {
+        patterns = patterns.filter(p => p.verified === options.verified);
+    }
+    // Trust level filter
+    if (options.trustLevel) {
+        const trustLevels = ['unverified', 'community', 'verified', 'official'];
+        const minLevel = trustLevels.indexOf(options.trustLevel);
+        patterns = patterns.filter(p => {
+            const patternLevel = trustLevels.indexOf(p.trustLevel);
+            return patternLevel >= minLevel;
+        });
+    }
+    // Sort
+    const sortBy = options.sortBy || 'downloads';
+    const sortOrder = options.sortOrder || 'desc';
+    patterns.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;
+        }
+        return sortOrder === 'desc' ? -comparison : comparison;
+    });
+    // Pagination
+    const total = patterns.length;
+    const limit = options.limit || 20;
+    const offset = options.offset || 0;
+    const page = Math.floor(offset / limit) + 1;
+    patterns = patterns.slice(offset, offset + limit);
+    return {
+        patterns,
+        total,
+        page,
+        pageSize: limit,
+        hasMore: offset + patterns.length < total,
+        query: options,
+    };
+}
+/**
+ * Get featured patterns
+ */
+export function getFeaturedPatterns(registry) {
+    return registry.featured
+        .map(id => registry.patterns.find(p => p.id === id))
+        .filter((p) => p !== undefined);
+}
+/**
+ * Get trending patterns
+ */
+export function getTrendingPatterns(registry) {
+    return registry.trending
+        .map(id => registry.patterns.find(p => p.id === id))
+        .filter((p) => p !== undefined);
+}
+/**
+ * Get newest patterns
+ */
+export function getNewestPatterns(registry) {
+    return registry.newest
+        .map(id => registry.patterns.find(p => p.id === id))
+        .filter((p) => p !== undefined);
+}
+/**
+ * Get pattern by ID
+ */
+export function getPatternById(registry, patternId) {
+    return registry.patterns.find(p => p.id === patternId);
+}
+/**
+ * Get pattern by name
+ */
+export function getPatternByName(registry, name) {
+    return registry.patterns.find(p => p.name === name);
+}
+/**
+ * Get patterns by author
+ */
+export function getPatternsByAuthor(registry, authorId) {
+    return registry.patterns.filter(p => p.author.id === authorId);
+}
+/**
+ * Get patterns by category
+ */
+export function getPatternsByCategory(registry, categoryId) {
+    return registry.patterns.filter(p => p.categories.includes(categoryId));
+}
+/**
+ * Get similar patterns (by tags and category)
+ */
+export function getSimilarPatterns(registry, pattern, limit = 5) {
+    const scores = new Map();
+    for (const p of registry.patterns) {
+        if (p.id === pattern.id)
+            continue;
+        let score = 0;
+        // Shared tags
+        const sharedTags = p.tags.filter(t => pattern.tags.includes(t));
+        score += sharedTags.length * 2;
+        // Shared categories
+        const sharedCategories = p.categories.filter(c => pattern.categories.includes(c));
+        score += sharedCategories.length * 3;
+        // Same language
+        if (p.language === pattern.language)
+            score += 1;
+        // Same framework
+        if (p.framework === pattern.framework)
+            score += 2;
+        // Same author
+        if (p.author.id === pattern.author.id)
+            score += 1;
+        if (score > 0) {
+            scores.set(p.id, score);
+        }
+    }
+    // Sort by score and return top matches
+    return Array.from(scores.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([id]) => registry.patterns.find(p => p.id === id))
+        .filter(p => p !== undefined);
+}
+/**
+ * Get category stats
+ */
+export function getCategoryStats(registry) {
+    const stats = new Map();
+    for (const category of registry.categories) {
+        const count = registry.patterns.filter(p => p.categories.includes(category.id)).length;
+        stats.set(category.id, count);
+    }
+    return stats;
+}
+/**
+ * Get tag cloud (tag -> count)
+ */
+export function getTagCloud(registry) {
+    const tags = new Map();
+    for (const pattern of registry.patterns) {
+        for (const tag of pattern.tags) {
+            tags.set(tag, (tags.get(tag) || 0) + 1);
+        }
+    }
+    return tags;
+}
+/**
+ * Autocomplete search suggestions
+ */
+export function getSearchSuggestions(registry, partial, limit = 10) {
+    const suggestions = new Set();
+    const query = partial.toLowerCase();
+    // Add matching pattern names
+    for (const pattern of registry.patterns) {
+        if (pattern.name.toLowerCase().includes(query)) {
+            suggestions.add(pattern.name);
+        }
+        if (pattern.displayName.toLowerCase().includes(query)) {
+            suggestions.add(pattern.displayName);
+        }
+    }
+    // Add matching tags
+    for (const pattern of registry.patterns) {
+        for (const tag of pattern.tags) {
+            if (tag.toLowerCase().includes(query)) {
+                suggestions.add(tag);
+            }
+        }
+    }
+    // Add matching categories
+    for (const category of registry.categories) {
+        if (category.name.toLowerCase().includes(query)) {
+            suggestions.add(category.name);
+        }
+    }
+    return Array.from(suggestions).slice(0, limit);
+}
+//# sourceMappingURL=search.js.map

package/dist/src/transfer/store/tests/standalone-test.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env npx tsx
+/**
+ * Standalone Pattern Store Test
+ * Run this in any environment to verify the IPFS-based pattern store works
+ *
+ * Usage:
+ *   npx tsx standalone-test.ts
+ *   # or
+ *   npm run test:pattern-store
+ */
+export {};
+//# sourceMappingURL=standalone-test.d.ts.map

package/dist/src/transfer/store/tests/standalone-test.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env npx tsx
+/**
+ * Standalone Pattern Store Test
+ * Run this in any environment to verify the IPFS-based pattern store works
+ *
+ * Usage:
+ *   npx tsx standalone-test.ts
+ *   # or
+ *   npm run test:pattern-store
+ */
+import { PatternStore, createDiscoveryService, searchPatterns, getFeaturedPatterns, getTrendingPatterns, getNewestPatterns, getCategoryStats, getTagCloud, getSearchSuggestions, } from '../index.js';
+async function main() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════════╗');
+    console.log('║  CLAUDE FLOW V3 - STANDALONE PATTERN STORE TEST              ║');
+    console.log('║  IPFS-Based Decentralized Pattern Marketplace                ║');
+    console.log('╚══════════════════════════════════════════════════════════════╝');
+    console.log('');
+    let passed = 0;
+    let failed = 0;
+    // Test 1: Discovery Service Creation
+    console.log('▶ Test 1: Create Discovery Service');
+    try {
+        const discovery = createDiscoveryService();
+        const registries = discovery.listRegistries();
+        console.log(`  ✅ Created service with ${registries.length} bootstrap registries`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 2: Discover Registry
+    console.log('▶ Test 2: Discover Registry via IPNS');
+    let registry = null;
+    try {
+        const discovery = createDiscoveryService();
+        const result = await discovery.discoverRegistry();
+        if (result.success && result.registry) {
+            registry = result.registry;
+            console.log(`  ✅ Discovered ${result.registry.patterns.length} patterns from ${result.source}`);
+            passed++;
+        }
+        else {
+            throw new Error(result.error || 'No registry');
+        }
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    if (!registry) {
+        console.log('\n❌ Cannot continue without registry\n');
+        process.exit(1);
+    }
+    // Test 3: Search Patterns
+    console.log('▶ Test 3: Search for "agent"');
+    try {
+        const results = searchPatterns(registry, { query: 'agent' });
+        console.log(`  ✅ Found ${results.patterns.length} patterns matching "agent"`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 4: Get Featured Patterns
+    console.log('▶ Test 4: Get Featured Patterns');
+    try {
+        const featured = getFeaturedPatterns(registry);
+        console.log(`  ✅ Found ${featured.length} featured patterns`);
+        if (featured.length > 0) {
+            console.log(`     - ${featured[0].name} (${featured[0].id})`);
+        }
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 5: Get Trending Patterns
+    console.log('▶ Test 5: Get Trending Patterns');
+    try {
+        const trending = getTrendingPatterns(registry);
+        console.log(`  ✅ Found ${trending.length} trending patterns`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 6: Get Newest Patterns
+    console.log('▶ Test 6: Get Newest Patterns');
+    try {
+        const newest = getNewestPatterns(registry);
+        console.log(`  ✅ Found ${newest.length} newest patterns`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 7: Search with Filters
+    console.log('▶ Test 7: Search with Filters (verified only)');
+    try {
+        const results = searchPatterns(registry, { verified: true });
+        console.log(`  ✅ Found ${results.patterns.length} verified patterns`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 8: Category Stats
+    console.log('▶ Test 8: Get Category Statistics');
+    try {
+        const stats = getCategoryStats(registry);
+        const count = Array.isArray(stats) ? stats.length : Object.keys(stats).length;
+        console.log(`  ✅ Found ${count} categories with stats`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 9: Tag Cloud
+    console.log('▶ Test 9: Get Tag Cloud');
+    try {
+        const tags = getTagCloud(registry);
+        console.log(`  ✅ Found ${tags.size} unique tags`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 10: Search Suggestions
+    console.log('▶ Test 10: Get Search Suggestions');
+    try {
+        const suggestions = getSearchSuggestions(registry, 'pat');
+        console.log(`  ✅ Got ${suggestions.length} suggestions for "pat"`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Test 11: PatternStore Class
+    console.log('▶ Test 11: PatternStore Class API');
+    try {
+        const store = new PatternStore();
+        await store.initialize();
+        const stats = store.getStats();
+        console.log(`  ✅ PatternStore initialized:`);
+        console.log(`     Total Patterns: ${stats.totalPatterns}`);
+        console.log(`     Total Downloads: ${stats.totalDownloads.toLocaleString()}`);
+        console.log(`     Categories: ${stats.categories}`);
+        passed++;
+    }
+    catch (e) {
+        console.log(`  ❌ Failed: ${e.message}`);
+        failed++;
+    }
+    // Summary
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('                        TEST RESULTS                            ');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+    console.log(`  Total:  ${passed + failed}`);
+    console.log(`  ✅ Passed: ${passed}`);
+    console.log(`  ❌ Failed: ${failed}`);
+    console.log('');
+    if (failed === 0) {
+        console.log('  🎉 All tests passed! Pattern Store is working correctly.');
+        console.log('');
+        console.log('  Available CLI Commands:');
+        console.log('    npx @claude-flow/cli patterns list');
+        console.log('    npx @claude-flow/cli patterns list --featured');
+        console.log('    npx @claude-flow/cli patterns search -q "agent"');
+        console.log('    npx @claude-flow/cli patterns info -n <pattern-id>');
+        console.log('');
+    }
+    process.exit(failed > 0 ? 1 : 0);
+}
+main().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=standalone-test.js.map

package/dist/src/transfer/store/types.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Pattern Store Types
+ * Decentralized pattern marketplace using IPFS
+ */
+import type { TrustLevel, AnonymizationLevel } from '../types.js';
+/**
+ * Pattern entry in the registry
+ */
+export interface PatternEntry {
+    id: string;
+    name: string;
+    displayName: string;
+    description: string;
+    version: string;
+    cid: string;
+    size: number;
+    checksum: string;
+    author: PatternAuthor;
+    license: string;
+    categories: string[];
+    tags: string[];
+    language?: string;
+    framework?: string;
+    downloads: number;
+    rating: number;
+    ratingCount: number;
+    lastUpdated: string;
+    createdAt: string;
+    minClaudeFlowVersion: string;
+    dependencies?: string[];
+    verified: boolean;
+    trustLevel: TrustLevel;
+    signature?: string;
+    publicKey?: string;
+}
+/**
+ * Pattern author info
+ */
+export interface PatternAuthor {
+    id: string;
+    displayName?: string;
+    publicKey?: string;
+    verified: boolean;
+    patterns: number;
+    totalDownloads: number;
+}
+/**
+ * Category in the registry
+ */
+export interface PatternCategory {
+    id: string;
+    name: string;
+    description: string;
+    patternCount: number;
+    icon?: string;
+    subcategories?: PatternCategory[];
+}
+/**
+ * Decentralized registry structure
+ * Stored on IPFS with IPNS pointer for updates
+ */
+export interface PatternRegistry {
+    version: string;
+    updatedAt: string;
+    ipnsName: string;
+    previousCid?: string;
+    patterns: PatternEntry[];
+    categories: PatternCategory[];
+    authors: PatternAuthor[];
+    totalPatterns: number;
+    totalDownloads: number;
+    totalAuthors: number;
+    featured: string[];
+    trending: string[];
+    newest: string[];
+    registrySignature?: string;
+    registryPublicKey?: string;
+}
+/**
+ * Search query options
+ */
+export interface SearchOptions {
+    query?: string;
+    category?: string;
+    language?: string;
+    framework?: string;
+    tags?: string[];
+    author?: string;
+    minRating?: number;
+    minDownloads?: number;
+    verified?: boolean;
+    trustLevel?: TrustLevel;
+    sortBy?: 'downloads' | 'rating' | 'newest' | 'name';
+    sortOrder?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Search result
+ */
+export interface SearchResult {
+    patterns: PatternEntry[];
+    total: number;
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+    query: SearchOptions;
+}
+/**
+ * Publish options
+ */
+export interface PublishOptions {
+    name: string;
+    displayName: string;
+    description: string;
+    categories: string[];
+    tags: string[];
+    license: string;
+    language?: string;
+    framework?: string;
+    anonymize: AnonymizationLevel;
+    privateKeyPath?: string;
+}
+/**
+ * Publish result
+ */
+export interface PublishResult {
+    success: boolean;
+    patternId: string;
+    cid: string;
+    registryCid: string;
+    gatewayUrl: string;
+    message: string;
+}
+/**
+ * Download options
+ */
+export interface DownloadOptions {
+    output?: string;
+    verify?: boolean;
+    import?: boolean;
+    importStrategy?: 'replace' | 'merge' | 'append';
+}
+/**
+ * Download result
+ */
+export interface DownloadResult {
+    success: boolean;
+    pattern: PatternEntry;
+    outputPath?: string;
+    imported?: boolean;
+    verified: boolean;
+    size: number;
+}
+/**
+ * Known registries (bootstrap nodes)
+ */
+export interface KnownRegistry {
+    name: string;
+    description: string;
+    ipnsName: string;
+    gateway: string;
+    publicKey: string;
+    trusted: boolean;
+}
+/**
+ * Store configuration
+ */
+export interface StoreConfig {
+    registries: KnownRegistry[];
+    defaultRegistry: string;
+    gateway: string;
+    timeout: number;
+    cacheDir: string;
+    cacheExpiry: number;
+    requireVerification: boolean;
+    minTrustLevel: TrustLevel;
+    trustedAuthors: string[];
+    blockedPatterns: string[];
+    authorId?: string;
+    privateKeyPath?: string;
+}
+/**
+ * Rating submission
+ */
+export interface RatingSubmission {
+    patternId: string;
+    rating: number;
+    comment?: string;
+    authorId: string;
+    signature: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/transfer/store/types.js

@@ -0,0 +1,6 @@
+/**
+ * Pattern Store Types
+ * Decentralized pattern marketplace using IPFS
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/transfer/test-seraphine.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Test Seraphine Genesis Model
+ * Quick validation of the transfer pipeline
+ */
+export {};
+//# sourceMappingURL=test-seraphine.d.ts.map