@claude-flow/cli 3.32.1 → 3.32.3

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

@@ -1,294 +0,0 @@
-/**
- * Pattern Publish Service
- * Publish and contribute patterns to decentralized registry
- */
-import * as fs from 'fs';
-import * as crypto from 'crypto';
-import { DEFAULT_STORE_CONFIG, generatePatternId } from './registry.js';
-import { anonymizeCFP } from '../anonymization/index.js';
-import { uploadToIPFS, pinContent } from '../ipfs/upload.js';
-/**
- * Pattern Publisher
- * Handles publishing patterns to IPFS and registry
- */
-export class PatternPublisher {
-    config;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_STORE_CONFIG, ...config };
-    }
-    /**
-     * Publish a pattern to IPFS and registry
-     */
-    async publishPattern(cfp, options) {
-        console.log(`[Publish] Starting publish: ${options.name}`);
-        try {
-            // Step 1: Anonymize if needed
-            const anonymized = anonymizeCFP(cfp, options.anonymize);
-            console.log(`[Publish] Anonymization level: ${options.anonymize}`);
-            // Step 2: Serialize content
-            const content = JSON.stringify(anonymized, null, 2);
-            const contentBuffer = Buffer.from(content);
-            // Step 3: Calculate checksum
-            const checksum = crypto
-                .createHash('sha256')
-                .update(contentBuffer)
-                .digest('hex');
-            // Step 4: Sign if private key provided
-            let signature;
-            let publicKey;
-            if (options.privateKeyPath && fs.existsSync(options.privateKeyPath)) {
-                const signResult = this.signContent(contentBuffer, options.privateKeyPath);
-                signature = signResult.signature;
-                publicKey = signResult.publicKey;
-                console.log(`[Publish] Content signed`);
-            }
-            // Get author info early (needed for GCS metadata and pattern entry)
-            const author = this.getAuthor();
-            // Step 5: Upload to IPFS or GCS
-            let uploadCid;
-            let gatewayUrl;
-            // Check if GCS is configured
-            try {
-                const { hasGCSCredentials, uploadToGCS } = await import('../storage/gcs.js');
-                if (hasGCSCredentials()) {
-                    console.log(`[Publish] Uploading to Google Cloud Storage...`);
-                    const gcsResult = await uploadToGCS(contentBuffer, {
-                        name: `${options.name}.cfp.json`,
-                        metadata: {
-                            checksum,
-                            author: author.id,
-                            version: cfp.version,
-                        },
-                    });
-                    if (gcsResult.success) {
-                        uploadCid = gcsResult.uri; // Use GCS URI as CID
-                        gatewayUrl = gcsResult.publicUrl;
-                        console.log(`[Publish] Uploaded to GCS: ${gcsResult.uri}`);
-                    }
-                    else {
-                        throw new Error('GCS upload failed');
-                    }
-                }
-                else {
-                    throw new Error('GCS not configured');
-                }
-            }
-            catch {
-                // Fallback to IPFS
-                console.log(`[Publish] Uploading to IPFS...`);
-                const uploadResult = await uploadToIPFS(contentBuffer, {
-                    name: `${options.name}.cfp.json`,
-                    pin: true,
-                });
-                if (!uploadResult.cid) {
-                    return {
-                        success: false,
-                        patternId: '',
-                        cid: '',
-                        registryCid: '',
-                        gatewayUrl: '',
-                        message: 'Failed to upload to IPFS (no IPFS credentials configured)',
-                    };
-                }
-                uploadCid = uploadResult.cid;
-                gatewayUrl = `${this.config.gateway}/ipfs/${uploadResult.cid}`;
-                console.log(`[Publish] Uploaded to IPFS: ${uploadResult.cid}`);
-                // Pin content
-                await pinContent(uploadResult.cid);
-            }
-            // Step 6: Create pattern entry
-            const patternId = generatePatternId(options.name);
-            const patternEntry = {
-                id: patternId,
-                name: options.name,
-                displayName: options.displayName,
-                description: options.description,
-                version: cfp.version,
-                cid: uploadCid,
-                size: contentBuffer.length,
-                checksum,
-                author,
-                license: options.license,
-                categories: options.categories,
-                tags: options.tags,
-                language: options.language,
-                framework: options.framework,
-                downloads: 0,
-                rating: 0,
-                ratingCount: 0,
-                lastUpdated: new Date().toISOString(),
-                createdAt: new Date().toISOString(),
-                minClaudeFlowVersion: '3.0.0',
-                verified: author.verified,
-                trustLevel: author.verified ? 'verified' : 'community',
-                signature,
-                publicKey,
-            };
-            // Step 7: Add to registry (in production: submit to registry maintainers)
-            console.log(`[Publish] Pattern entry created: ${patternId}`);
-            return {
-                success: true,
-                patternId,
-                cid: uploadCid,
-                registryCid: '', // Would be updated after registry update
-                gatewayUrl,
-                message: `Pattern '${options.displayName}' published successfully!`,
-            };
-        }
-        catch (error) {
-            console.error(`[Publish] Failed:`, error);
-            return {
-                success: false,
-                patternId: '',
-                cid: '',
-                registryCid: '',
-                gatewayUrl: '',
-                message: `Publish failed: ${error}`,
-            };
-        }
-    }
-    /**
-     * Sign content with private key
-     */
-    signContent(content, privateKeyPath) {
-        // In production: Use actual Ed25519 signing
-        // For demo: Generate mock signature
-        const privateKey = fs.readFileSync(privateKeyPath, 'utf-8').trim();
-        const signature = crypto
-            .createHmac('sha256', privateKey)
-            .update(content)
-            .digest('hex');
-        const publicKey = 'ed25519:' +
-            crypto.createHash('sha256').update(privateKey).digest('hex').slice(0, 32);
-        return {
-            signature: `ed25519:${signature}`,
-            publicKey,
-        };
-    }
-    /**
-     * Get current author info
-     */
-    getAuthor() {
-        if (this.config.authorId) {
-            return {
-                id: this.config.authorId,
-                displayName: this.config.authorId,
-                verified: false,
-                patterns: 0,
-                totalDownloads: 0,
-            };
-        }
-        // Anonymous author
-        return {
-            id: `anon-${crypto.randomBytes(8).toString('hex')}`,
-            verified: false,
-            patterns: 0,
-            totalDownloads: 0,
-        };
-    }
-    /**
-     * Validate pattern before publish
-     */
-    validateForPublish(cfp, options) {
-        const errors = [];
-        // Check required fields
-        if (!options.name || options.name.length < 3) {
-            errors.push('Name must be at least 3 characters');
-        }
-        if (!options.displayName || options.displayName.length < 3) {
-            errors.push('Display name must be at least 3 characters');
-        }
-        if (!options.description || options.description.length < 20) {
-            errors.push('Description must be at least 20 characters');
-        }
-        if (!options.categories || options.categories.length === 0) {
-            errors.push('At least one category is required');
-        }
-        if (!options.tags || options.tags.length < 3) {
-            errors.push('At least 3 tags are required');
-        }
-        // Check valid license
-        const validLicenses = ['MIT', 'Apache-2.0', 'GPL-3.0', 'BSD-3-Clause', 'CC-BY-4.0', 'Unlicense'];
-        if (!validLicenses.includes(options.license)) {
-            errors.push(`License must be one of: ${validLicenses.join(', ')}`);
-        }
-        // Check pattern content
-        if (cfp.magic !== 'CFP1') {
-            errors.push('Invalid CFP format (missing magic header)');
-        }
-        const totalPatterns = cfp.statistics.totalPatterns;
-        if (totalPatterns === 0) {
-            errors.push('Pattern must contain at least one pattern');
-        }
-        return errors;
-    }
-    /**
-     * Create publish preview
-     */
-    createPreview(cfp, options) {
-        return {
-            name: options.name,
-            displayName: options.displayName,
-            description: options.description,
-            categories: options.categories,
-            tags: options.tags,
-            license: options.license,
-            language: options.language,
-            framework: options.framework,
-            anonymization: options.anonymize,
-            statistics: cfp.statistics,
-            estimatedSize: JSON.stringify(cfp).length,
-        };
-    }
-}
-/**
- * Submit a contribution to the registry
- */
-export async function submitContribution(request) {
-    console.log(`[Contribute] Submitting contribution: ${request.name}`);
-    // In production: Submit to registry governance system
-    // For demo: Generate mock submission ID
-    const submissionId = `contrib-${crypto.randomBytes(8).toString('hex')}`;
-    console.log(`[Contribute] Submission ID: ${submissionId}`);
-    console.log(`[Contribute] Pattern CID: ${request.patternCid}`);
-    console.log(`[Contribute] Author: ${request.authorId}`);
-    return {
-        success: true,
-        submissionId,
-        message: `Contribution submitted for review. Track status with ID: ${submissionId}`,
-    };
-}
-/**
- * Check contribution status
- */
-export async function checkContributionStatus(submissionId) {
-    // In production: Query registry governance system
-    // For demo: Return mock status
-    return {
-        status: 'pending',
-        message: 'Your contribution is pending review',
-    };
-}
-/**
- * Create publisher with default config
- */
-export function createPublisher(config) {
-    return new PatternPublisher(config);
-}
-/**
- * Quick publish helper
- */
-export async function quickPublish(cfp, name, description, tags, config) {
-    const publisher = new PatternPublisher(config);
-    const options = {
-        name,
-        displayName: name.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
-        description,
-        categories: ['custom'],
-        tags,
-        license: 'MIT',
-        anonymize: 'standard',
-    };
-    return publisher.publishPattern(cfp, options);
-}
-//# sourceMappingURL=publish.js.map

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

@@ -1,58 +0,0 @@
-/**
- * Decentralized Pattern Registry
- * IPFS-based registry with IPNS for mutable references
- */
-import type { PatternRegistry, PatternEntry, PatternCategory, KnownRegistry, StoreConfig } from './types.js';
-/**
- * Registry version
- */
-export declare const REGISTRY_VERSION = "1.0.0";
-/**
- * Default bootstrap registries for discovery
- */
-export declare const BOOTSTRAP_REGISTRIES: KnownRegistry[];
-/**
- * Default store configuration
- */
-export declare const DEFAULT_STORE_CONFIG: StoreConfig;
-/**
- * Create a new empty registry
- */
-export declare function createRegistry(ipnsName: string): PatternRegistry;
-/**
- * Default pattern categories
- */
-export declare function getDefaultCategories(): PatternCategory[];
-/**
- * Add a pattern to the registry
- */
-export declare function addPatternToRegistry(registry: PatternRegistry, entry: PatternEntry): PatternRegistry;
-/**
- * Remove a pattern from the registry
- */
-export declare function removePatternFromRegistry(registry: PatternRegistry, patternId: string): PatternRegistry;
-/**
- * Serialize registry to JSON
- */
-export declare function serializeRegistry(registry: PatternRegistry): string;
-/**
- * Deserialize registry from JSON
- */
-export declare function deserializeRegistry(json: string): PatternRegistry;
-/**
- * Sign registry with private key
- */
-export declare function signRegistry(registry: PatternRegistry, privateKey: string): PatternRegistry;
-/**
- * Verify registry signature
- */
-export declare function verifyRegistrySignature(registry: PatternRegistry): boolean;
-/**
- * Merge two registries (for sync)
- */
-export declare function mergeRegistries(local: PatternRegistry, remote: PatternRegistry): PatternRegistry;
-/**
- * Generate pattern ID from name
- */
-export declare function generatePatternId(name: string): string;
-//# sourceMappingURL=registry.d.ts.map

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

@@ -1,285 +0,0 @@
-/**
- * Decentralized Pattern Registry
- * IPFS-based registry with IPNS for mutable references
- */
-import * as crypto from 'crypto';
-/**
- * Registry version
- */
-export const REGISTRY_VERSION = '1.0.0';
-/**
- * Default bootstrap registries for discovery
- */
-export const BOOTSTRAP_REGISTRIES = [
-    {
-        name: 'claude-flow-official',
-        description: 'Official Claude Flow pattern registry',
-        ipnsName: 'k51qzi5uqu5dj0w8q1xvqn8ql2g4p7x8qpk9vz3xm1y2n3o4p5q6r7s8t9u0v',
-        gateway: 'https://w3s.link',
-        publicKey: 'ed25519:claude-flow-registry-key',
-        trusted: true,
-    },
-    {
-        name: 'community-patterns',
-        description: 'Community-contributed patterns',
-        ipnsName: 'k51qzi5uqu5dkkph0w8q1xvqn8ql2g4p7x8qpk9vz3xm1y2n3o4p5q6r7s8',
-        gateway: 'https://dweb.link',
-        publicKey: 'ed25519:community-registry-key',
-        trusted: false,
-    },
-];
-/**
- * Default store configuration
- */
-export const DEFAULT_STORE_CONFIG = {
-    registries: BOOTSTRAP_REGISTRIES,
-    defaultRegistry: 'claude-flow-official',
-    gateway: 'https://w3s.link',
-    timeout: 30000,
-    cacheDir: '.claude-flow/patterns/cache',
-    cacheExpiry: 3600000, // 1 hour
-    requireVerification: false,
-    minTrustLevel: 'unverified',
-    trustedAuthors: [],
-    blockedPatterns: [],
-};
-/**
- * Create a new empty registry
- */
-export function createRegistry(ipnsName) {
-    return {
-        version: REGISTRY_VERSION,
-        updatedAt: new Date().toISOString(),
-        ipnsName,
-        patterns: [],
-        categories: getDefaultCategories(),
-        authors: [],
-        totalPatterns: 0,
-        totalDownloads: 0,
-        totalAuthors: 0,
-        featured: [],
-        trending: [],
-        newest: [],
-    };
-}
-/**
- * Default pattern categories
- */
-export function getDefaultCategories() {
-    return [
-        {
-            id: 'routing',
-            name: 'Task Routing',
-            description: 'Patterns for routing tasks to appropriate agents',
-            patternCount: 0,
-            icon: '🔀',
-        },
-        {
-            id: 'coordination',
-            name: 'Swarm Coordination',
-            description: 'Multi-agent coordination and communication patterns',
-            patternCount: 0,
-            icon: '🐝',
-        },
-        {
-            id: 'security',
-            name: 'Security',
-            description: 'Security analysis and vulnerability detection patterns',
-            patternCount: 0,
-            icon: '🔒',
-        },
-        {
-            id: 'performance',
-            name: 'Performance',
-            description: 'Performance optimization and profiling patterns',
-            patternCount: 0,
-            icon: '⚡',
-        },
-        {
-            id: 'testing',
-            name: 'Testing',
-            description: 'Test generation and quality assurance patterns',
-            patternCount: 0,
-            icon: '🧪',
-        },
-        {
-            id: 'documentation',
-            name: 'Documentation',
-            description: 'Documentation generation and maintenance patterns',
-            patternCount: 0,
-            icon: '📚',
-        },
-        {
-            id: 'refactoring',
-            name: 'Refactoring',
-            description: 'Code refactoring and improvement patterns',
-            patternCount: 0,
-            icon: '🔧',
-        },
-        {
-            id: 'language',
-            name: 'Language-Specific',
-            description: 'Patterns optimized for specific programming languages',
-            patternCount: 0,
-            icon: '💻',
-            subcategories: [
-                { id: 'typescript', name: 'TypeScript', description: 'TypeScript patterns', patternCount: 0 },
-                { id: 'python', name: 'Python', description: 'Python patterns', patternCount: 0 },
-                { id: 'rust', name: 'Rust', description: 'Rust patterns', patternCount: 0 },
-                { id: 'go', name: 'Go', description: 'Go patterns', patternCount: 0 },
-            ],
-        },
-        {
-            id: 'framework',
-            name: 'Framework-Specific',
-            description: 'Patterns for specific frameworks',
-            patternCount: 0,
-            icon: '🏗️',
-            subcategories: [
-                { id: 'react', name: 'React', description: 'React patterns', patternCount: 0 },
-                { id: 'nextjs', name: 'Next.js', description: 'Next.js patterns', patternCount: 0 },
-                { id: 'node', name: 'Node.js', description: 'Node.js patterns', patternCount: 0 },
-            ],
-        },
-    ];
-}
-/**
- * Add a pattern to the registry
- */
-export function addPatternToRegistry(registry, entry) {
-    const updated = { ...registry };
-    // Check for existing pattern with same name
-    const existingIndex = updated.patterns.findIndex(p => p.name === entry.name);
-    if (existingIndex >= 0) {
-        // Update existing
-        updated.patterns[existingIndex] = entry;
-    }
-    else {
-        // Add new
-        updated.patterns.push(entry);
-    }
-    // Update author
-    const authorIndex = updated.authors.findIndex(a => a.id === entry.author.id);
-    if (authorIndex >= 0) {
-        updated.authors[authorIndex].patterns++;
-    }
-    else {
-        updated.authors.push(entry.author);
-    }
-    // Update category counts
-    for (const cat of updated.categories) {
-        cat.patternCount = updated.patterns.filter(p => p.categories.includes(cat.id)).length;
-    }
-    // Update stats
-    updated.totalPatterns = updated.patterns.length;
-    updated.totalAuthors = updated.authors.length;
-    updated.updatedAt = new Date().toISOString();
-    // Update newest
-    updated.newest = updated.patterns
-        .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
-        .slice(0, 10)
-        .map(p => p.id);
-    // Update trending (by recent downloads - simplified)
-    updated.trending = updated.patterns
-        .sort((a, b) => b.downloads - a.downloads)
-        .slice(0, 10)
-        .map(p => p.id);
-    return updated;
-}
-/**
- * Remove a pattern from the registry
- */
-export function removePatternFromRegistry(registry, patternId) {
-    const updated = { ...registry };
-    updated.patterns = updated.patterns.filter(p => p.id !== patternId);
-    updated.totalPatterns = updated.patterns.length;
-    updated.updatedAt = new Date().toISOString();
-    return updated;
-}
-/**
- * Serialize registry to JSON
- */
-export function serializeRegistry(registry) {
-    return JSON.stringify(registry, null, 2);
-}
-/**
- * Deserialize registry from JSON
- */
-export function deserializeRegistry(json) {
-    const registry = JSON.parse(json);
-    // Validate version
-    if (!registry.version) {
-        throw new Error('Invalid registry: missing version');
-    }
-    return registry;
-}
-/**
- * Sign registry with private key
- */
-export function signRegistry(registry, privateKey) {
-    const content = JSON.stringify({
-        version: registry.version,
-        updatedAt: registry.updatedAt,
-        patterns: registry.patterns.map(p => p.cid),
-        totalPatterns: registry.totalPatterns,
-    });
-    // In production: Use actual Ed25519 signing
-    const signature = crypto
-        .createHmac('sha256', privateKey)
-        .update(content)
-        .digest('hex');
-    return {
-        ...registry,
-        registrySignature: signature,
-        registryPublicKey: 'ed25519:' + crypto.createHash('sha256').update(privateKey).digest('hex').slice(0, 32),
-    };
-}
-/**
- * Verify registry signature
- */
-export function verifyRegistrySignature(registry) {
-    if (!registry.registrySignature || !registry.registryPublicKey) {
-        return false;
-    }
-    // In production: Use actual Ed25519 verification
-    // For now, just check signature exists
-    return registry.registrySignature.length === 64;
-}
-/**
- * Merge two registries (for sync)
- */
-export function mergeRegistries(local, remote) {
-    const merged = createRegistry(local.ipnsName);
-    // Combine patterns, preferring newer versions
-    const patternMap = new Map();
-    for (const pattern of [...local.patterns, ...remote.patterns]) {
-        const existing = patternMap.get(pattern.name);
-        if (!existing || new Date(pattern.lastUpdated) > new Date(existing.lastUpdated)) {
-            patternMap.set(pattern.name, pattern);
-        }
-    }
-    merged.patterns = Array.from(patternMap.values());
-    // Combine authors
-    const authorMap = new Map();
-    for (const author of [...local.authors, ...remote.authors]) {
-        const existing = authorMap.get(author.id);
-        if (!existing || author.patterns > existing.patterns) {
-            authorMap.set(author.id, author);
-        }
-    }
-    merged.authors = Array.from(authorMap.values());
-    // Update stats
-    merged.totalPatterns = merged.patterns.length;
-    merged.totalAuthors = merged.authors.length;
-    merged.totalDownloads = merged.patterns.reduce((sum, p) => sum + p.downloads, 0);
-    return merged;
-}
-/**
- * Generate pattern ID from name
- */
-export function generatePatternId(name) {
-    const normalized = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-    const hash = crypto.createHash('sha256').update(name + Date.now()).digest('hex').slice(0, 8);
-    return `${normalized}-${hash}`;
-}
-//# sourceMappingURL=registry.js.map

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

@@ -1,54 +0,0 @@
-/**
- * Pattern Search Service
- * Search and filter patterns from decentralized registry
- */
-import type { PatternRegistry, PatternEntry, SearchOptions, SearchResult } from './types.js';
-/**
- * Search patterns in registry
- */
-export declare function searchPatterns(registry: PatternRegistry, options?: SearchOptions): SearchResult;
-/**
- * Get featured patterns
- */
-export declare function getFeaturedPatterns(registry: PatternRegistry): PatternEntry[];
-/**
- * Get trending patterns
- */
-export declare function getTrendingPatterns(registry: PatternRegistry): PatternEntry[];
-/**
- * Get newest patterns
- */
-export declare function getNewestPatterns(registry: PatternRegistry): PatternEntry[];
-/**
- * Get pattern by ID
- */
-export declare function getPatternById(registry: PatternRegistry, patternId: string): PatternEntry | undefined;
-/**
- * Get pattern by name
- */
-export declare function getPatternByName(registry: PatternRegistry, name: string): PatternEntry | undefined;
-/**
- * Get patterns by author
- */
-export declare function getPatternsByAuthor(registry: PatternRegistry, authorId: string): PatternEntry[];
-/**
- * Get patterns by category
- */
-export declare function getPatternsByCategory(registry: PatternRegistry, categoryId: string): PatternEntry[];
-/**
- * Get similar patterns (by tags and category)
- */
-export declare function getSimilarPatterns(registry: PatternRegistry, pattern: PatternEntry, limit?: number): PatternEntry[];
-/**
- * Get category stats
- */
-export declare function getCategoryStats(registry: PatternRegistry): Map<string, number>;
-/**
- * Get tag cloud (tag -> count)
- */
-export declare function getTagCloud(registry: PatternRegistry): Map<string, number>;
-/**
- * Autocomplete search suggestions
- */
-export declare function getSearchSuggestions(registry: PatternRegistry, partial: string, limit?: number): string[];
-//# sourceMappingURL=search.d.ts.map