@claude-flow/cli 3.32.1 → 3.32.3

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

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

@@ -1,12 +0,0 @@
-#!/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

@@ -1,190 +0,0 @@
-#!/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

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

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

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

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