@cloudpftc/opencode-orchestrator 3.5.15

package/v3/@claude-flow/cli/dist/src/transfer/store/publish.js

@@ -0,0 +1,294 @@
+/**
+ * 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/v3/@claude-flow/cli/dist/src/transfer/store/registry.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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/v3/@claude-flow/cli/dist/src/transfer/store/registry.js

@@ -0,0 +1,285 @@
+/**
+ * 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/v3/@claude-flow/cli/dist/src/transfer/store/search.d.ts

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