@claude-flow/cli 3.32.3 → 3.32.5

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

@@ -0,0 +1,13 @@
+#!/usr/bin/env npx tsx
+/**
+ * Deploy Seraphine Genesis Model
+ * Exports and uploads the first Claude Flow pattern model to IPFS
+ *
+ * Usage:
+ *   npx tsx deploy-seraphine.ts
+ *   npx tsx deploy-seraphine.ts --output ./patterns/
+ *   npx tsx deploy-seraphine.ts --to-ipfs
+ *   npx tsx deploy-seraphine.ts --to-ipfs --anonymize strict
+ */
+export {};
+//# sourceMappingURL=deploy-seraphine.d.ts.map

package/dist/src/transfer/deploy-seraphine.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env npx tsx
+/**
+ * Deploy Seraphine Genesis Model
+ * Exports and uploads the first Claude Flow pattern model to IPFS
+ *
+ * Usage:
+ *   npx tsx deploy-seraphine.ts
+ *   npx tsx deploy-seraphine.ts --output ./patterns/
+ *   npx tsx deploy-seraphine.ts --to-ipfs
+ *   npx tsx deploy-seraphine.ts --to-ipfs --anonymize strict
+ */
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { createSeraphineGenesis, getSeraphineInfo } from './models/seraphine.js';
+import { exportPatterns } from './export.js';
+import { validateCFP } from './serialization/cfp.js';
+import { scanCFPForPII } from './anonymization/index.js';
+/**
+ * Parse CLI arguments
+ */
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {
+        toIpfs: false,
+        anonymize: 'standard',
+        pin: true,
+        gateway: 'https://w3s.link',
+        validate: true,
+        verbose: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--output':
+            case '-o':
+                options.output = args[++i];
+                break;
+            case '--to-ipfs':
+            case '--ipfs':
+                options.toIpfs = true;
+                break;
+            case '--anonymize':
+            case '-a':
+                options.anonymize = args[++i];
+                break;
+            case '--no-pin':
+                options.pin = false;
+                break;
+            case '--gateway':
+            case '-g':
+                options.gateway = args[++i];
+                break;
+            case '--no-validate':
+                options.validate = false;
+                break;
+            case '--verbose':
+            case '-v':
+                options.verbose = true;
+                break;
+            case '--help':
+            case '-h':
+                printHelp();
+                process.exit(0);
+        }
+    }
+    return options;
+}
+/**
+ * Print help message
+ */
+function printHelp() {
+    console.log(`
+Seraphine Genesis Deployer
+==========================
+
+Deploy the foundational Claude Flow pattern model.
+
+Usage:
+  npx ts-node deploy-seraphine.ts [options]
+
+Options:
+  --output, -o <path>     Output file path
+  --to-ipfs, --ipfs       Upload to IPFS
+  --anonymize, -a <level> Anonymization level (minimal|standard|strict|paranoid)
+  --gateway, -g <url>     IPFS gateway URL
+  --no-pin                Don't pin to pinning service
+  --no-validate           Skip validation
+  --verbose, -v           Verbose output
+  --help, -h              Show this help
+
+Examples:
+  npx ts-node deploy-seraphine.ts --output ./seraphine-genesis.cfp.json
+  npx ts-node deploy-seraphine.ts --to-ipfs --anonymize strict
+  npx ts-node deploy-seraphine.ts --to-ipfs --gateway https://dweb.link
+`);
+}
+/**
+ * Main deploy function
+ */
+async function deploy() {
+    const options = parseArgs();
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════╗');
+    console.log('║        SERAPHINE GENESIS MODEL DEPLOYMENT                 ║');
+    console.log('║        The First Claude Flow Pattern Model                ║');
+    console.log('╚══════════════════════════════════════════════════════════╝');
+    console.log('');
+    // Step 1: Create Seraphine Genesis
+    console.log('📦 Creating Seraphine Genesis Model...');
+    const genesis = createSeraphineGenesis();
+    const info = getSeraphineInfo();
+    console.log(`   Name: ${info.name}`);
+    console.log(`   Version: ${info.version}`);
+    console.log(`   Description: ${info.description.slice(0, 60)}...`);
+    console.log('');
+    console.log('   Pattern Counts:');
+    for (const [type, count] of Object.entries(info.patternCounts)) {
+        console.log(`     - ${type}: ${count}`);
+    }
+    console.log('');
+    // Step 2: Validate
+    if (options.validate) {
+        console.log('✅ Validating CFP format...');
+        const validation = validateCFP(genesis);
+        if (!validation.valid) {
+            console.error('❌ Validation failed:');
+            for (const error of validation.errors) {
+                console.error(`   - ${error}`);
+            }
+            process.exit(1);
+        }
+        console.log('   Format is valid!');
+        console.log('');
+    }
+    // Step 3: Scan for PII
+    console.log('🔍 Scanning for PII...');
+    const piiScan = scanCFPForPII(genesis);
+    if (piiScan.found) {
+        console.log(`   Found ${piiScan.count} PII items:`);
+        for (const [type, count] of Object.entries(piiScan.types)) {
+            console.log(`     - ${type}: ${count}`);
+        }
+        console.log('   Will be redacted during export.');
+    }
+    else {
+        console.log('   No PII detected!');
+    }
+    console.log('');
+    // Step 4: Export
+    console.log(`📤 Exporting with ${options.anonymize} anonymization...`);
+    const exportOptions = {
+        output: options.output,
+        toIpfs: options.toIpfs,
+        anonymize: options.anonymize,
+        pin: options.pin,
+        gateway: options.gateway,
+        format: 'json',
+        redactPii: true,
+    };
+    // If no output specified and not uploading to IPFS, create default output
+    if (!options.output && !options.toIpfs) {
+        const defaultOutput = path.join(process.cwd(), 'seraphine-genesis.cfp.json');
+        exportOptions.output = defaultOutput;
+    }
+    const result = await exportPatterns(genesis, exportOptions);
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('                    DEPLOYMENT COMPLETE                     ');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('');
+    if (result.success) {
+        console.log('✅ Successfully deployed Seraphine Genesis!');
+        console.log('');
+        console.log('   📊 Export Summary:');
+        console.log(`      Patterns: ${result.patternCount}`);
+        console.log(`      Size: ${result.size} bytes`);
+        console.log(`      Anonymization: ${result.anonymizationLevel}`);
+        if (result.outputPath) {
+            console.log('');
+            console.log(`   📁 File: ${result.outputPath}`);
+        }
+        if (result.cid) {
+            console.log('');
+            console.log('   🌐 IPFS:');
+            console.log(`      CID: ${result.cid}`);
+            console.log(`      Gateway URL: ${result.gateway}/ipfs/${result.cid}`);
+        }
+        console.log('');
+        console.log('   🎉 Hello World! The genesis pattern has been deployed.');
+        console.log('   🌟 This is the first Claude Flow pattern ever shared.');
+        console.log('');
+    }
+    else {
+        console.error('❌ Deployment failed!');
+        process.exit(1);
+    }
+}
+// Run if executed directly
+deploy().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=deploy-seraphine.js.map

package/dist/src/transfer/export.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pattern Export Pipeline
+ * Export patterns with anonymization and optional IPFS upload
+ */
+import type { CFPFormat, ExportOptions, ExportResult } from './types.js';
+/**
+ * Export patterns to file or IPFS
+ */
+export declare function exportPatterns(cfp: CFPFormat, options?: ExportOptions): Promise<ExportResult>;
+/**
+ * Export Seraphine genesis model
+ */
+export declare function exportSeraphine(options?: ExportOptions): Promise<ExportResult>;
+/**
+ * Quick export to file
+ */
+export declare function quickExport(cfp: CFPFormat, outputPath: string): Promise<ExportResult>;
+/**
+ * Quick export to IPFS
+ */
+export declare function quickExportToIPFS(cfp: CFPFormat, options?: {
+    gateway?: string;
+    pin?: boolean;
+}): Promise<ExportResult>;
+//# sourceMappingURL=export.d.ts.map

package/dist/src/transfer/export.js

@@ -0,0 +1,113 @@
+/**
+ * Pattern Export Pipeline
+ * Export patterns with anonymization and optional IPFS upload
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { serializeToJson, serializeToBuffer, getFileExtension } from './serialization/cfp.js';
+import { anonymizeCFP, scanCFPForPII } from './anonymization/index.js';
+import { uploadToIPFS } from './ipfs/upload.js';
+/**
+ * Export patterns to file or IPFS
+ */
+export async function exportPatterns(cfp, options = {}) {
+    const { output, format = 'json', anonymize = 'standard', redactPii = true, stripPaths = false, toIpfs = false, pin = true, gateway = 'https://w3s.link', } = options;
+    // Step 1: Scan for PII
+    const piiScan = scanCFPForPII(cfp);
+    if (piiScan.found && redactPii) {
+        console.log(`Found ${piiScan.count} PII items, will be redacted`);
+    }
+    // Step 2: Apply anonymization
+    const { cfp: anonymizedCfp, transforms } = anonymizeCFP(cfp, anonymize);
+    console.log(`Applied ${transforms.length} anonymization transforms: ${transforms.join(', ')}`);
+    // Step 3: Serialize
+    const serialized = format === 'json'
+        ? serializeToJson(anonymizedCfp)
+        : serializeToBuffer(anonymizedCfp, format);
+    const size = typeof serialized === 'string' ? Buffer.byteLength(serialized) : serialized.length;
+    // Step 4: Output
+    let outputPath;
+    let cid;
+    if (toIpfs) {
+        // Upload to IPFS
+        const ipfsResult = await uploadToIPFS(Buffer.isBuffer(serialized) ? serialized : Buffer.from(serialized), {
+            pin,
+            gateway,
+            name: anonymizedCfp.metadata.name || 'patterns',
+        });
+        cid = ipfsResult.cid;
+        anonymizedCfp.ipfs = {
+            cid: ipfsResult.cid,
+            pinnedAt: ipfsResult.pinnedAt ? [ipfsResult.pinnedAt] : [],
+            gateway: ipfsResult.gateway,
+            size: ipfsResult.size,
+        };
+        console.log(`Uploaded to IPFS: ${cid}`);
+        console.log(`Gateway URL: ${gateway}/ipfs/${cid}`);
+    }
+    if (output) {
+        // Write to file
+        const ext = getFileExtension(format);
+        outputPath = output.endsWith(ext) ? output : output + ext;
+        // Ensure directory exists
+        const dir = path.dirname(outputPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Write file
+        if (typeof serialized === 'string') {
+            fs.writeFileSync(outputPath, serialized, 'utf-8');
+        }
+        else {
+            fs.writeFileSync(outputPath, serialized);
+        }
+        console.log(`Exported to: ${outputPath}`);
+    }
+    // Calculate pattern count
+    const patternCount = (cfp.patterns.routing?.length || 0) +
+        (cfp.patterns.complexity?.length || 0) +
+        (cfp.patterns.coverage?.length || 0) +
+        (cfp.patterns.trajectory?.length || 0) +
+        (cfp.patterns.custom?.length || 0);
+    return {
+        success: true,
+        outputPath,
+        cid,
+        gateway: cid ? gateway : undefined,
+        size,
+        patternCount,
+        anonymizationLevel: anonymize,
+    };
+}
+/**
+ * Export Seraphine genesis model
+ */
+export async function exportSeraphine(options = {}) {
+    // Dynamically import to avoid circular dependency
+    const { createSeraphineGenesis } = await import('./models/seraphine.js');
+    const genesis = createSeraphineGenesis();
+    return exportPatterns(genesis, options);
+}
+/**
+ * Quick export to file
+ */
+export async function quickExport(cfp, outputPath) {
+    return exportPatterns(cfp, {
+        output: outputPath,
+        format: 'json',
+        anonymize: 'standard',
+    });
+}
+/**
+ * Quick export to IPFS
+ */
+export async function quickExportToIPFS(cfp, options = {}) {
+    return exportPatterns(cfp, {
+        toIpfs: true,
+        pin: options.pin ?? true,
+        gateway: options.gateway ?? 'https://w3s.link',
+        format: 'json',
+        anonymize: 'strict',
+    });
+}
+//# sourceMappingURL=export.js.map

package/dist/src/transfer/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Transfer Module
+ * Pattern export, import, anonymization, and IPFS sharing
+ */
+export * from './types.js';
+export { createCFP, serializeToJson, serializeToBuffer, deserializeCFP, validateCFP, getFileExtension, detectFormat, } from './serialization/cfp.js';
+export { detectPII, redactPII, anonymizeCFP, scanCFPForPII, } from './anonymization/index.js';
+export { exportPatterns, exportSeraphine, quickExport, quickExportToIPFS, } from './export.js';
+export { uploadToIPFS, pinContent, unpinContent, checkContent, getGatewayURL, getIPNSURL, } from './ipfs/upload.js';
+export { SERAPHINE_VERSION, SERAPHINE_METADATA, SERAPHINE_ROUTING_PATTERNS, SERAPHINE_COMPLEXITY_PATTERNS, SERAPHINE_COVERAGE_PATTERNS, SERAPHINE_TRAJECTORY_PATTERNS, SERAPHINE_CUSTOM_PATTERNS, createSeraphinePatterns, createSeraphineGenesis, getSeraphineInfo, } from './models/seraphine.js';
+export { type PatternEntry, type PatternAuthor, type PatternCategory, type PatternRegistry, type SearchOptions, type SearchResult, type PublishOptions, type PublishResult, type DownloadOptions, type DownloadResult, type KnownRegistry, type StoreConfig, type DiscoveryResult, type IPNSResolution, type DownloadProgressCallback, type ContributionRequest, REGISTRY_VERSION, BOOTSTRAP_REGISTRIES, DEFAULT_STORE_CONFIG, createRegistry, getDefaultCategories, addPatternToRegistry, removePatternFromRegistry, serializeRegistry, deserializeRegistry, signRegistry, verifyRegistrySignature, mergeRegistries, generatePatternId, PatternDiscovery, createDiscoveryService, searchPatterns, getFeaturedPatterns, getTrendingPatterns, getNewestPatterns, getPatternById, getPatternByName, getPatternsByAuthor, getPatternsByCategory, getSimilarPatterns, getCategoryStats, getTagCloud, getSearchSuggestions, PatternDownloader, batchDownload, createDownloader, PatternPublisher, submitContribution, checkContributionStatus, createPublisher, quickPublish, PatternStore, createPatternStore, } from './store/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/transfer/index.js

@@ -0,0 +1,31 @@
+/**
+ * Transfer Module
+ * Pattern export, import, anonymization, and IPFS sharing
+ */
+// Types
+export * from './types.js';
+// Serialization
+export { createCFP, serializeToJson, serializeToBuffer, deserializeCFP, validateCFP, getFileExtension, detectFormat, } from './serialization/cfp.js';
+// Anonymization
+export { detectPII, redactPII, anonymizeCFP, scanCFPForPII, } from './anonymization/index.js';
+// Export
+export { exportPatterns, exportSeraphine, quickExport, quickExportToIPFS, } from './export.js';
+// IPFS
+export { uploadToIPFS, pinContent, unpinContent, checkContent, getGatewayURL, getIPNSURL, } from './ipfs/upload.js';
+// Models
+export { SERAPHINE_VERSION, SERAPHINE_METADATA, SERAPHINE_ROUTING_PATTERNS, SERAPHINE_COMPLEXITY_PATTERNS, SERAPHINE_COVERAGE_PATTERNS, SERAPHINE_TRAJECTORY_PATTERNS, SERAPHINE_CUSTOM_PATTERNS, createSeraphinePatterns, createSeraphineGenesis, getSeraphineInfo, } from './models/seraphine.js';
+// Store - Decentralized Pattern Marketplace
+export { 
+// Registry
+REGISTRY_VERSION, BOOTSTRAP_REGISTRIES, DEFAULT_STORE_CONFIG, createRegistry, getDefaultCategories, addPatternToRegistry, removePatternFromRegistry, serializeRegistry, deserializeRegistry, signRegistry, verifyRegistrySignature, mergeRegistries, generatePatternId, 
+// Discovery
+PatternDiscovery, createDiscoveryService, 
+// Search
+searchPatterns, getFeaturedPatterns, getTrendingPatterns, getNewestPatterns, getPatternById, getPatternByName, getPatternsByAuthor, getPatternsByCategory, getSimilarPatterns, getCategoryStats, getTagCloud, getSearchSuggestions, 
+// Download
+PatternDownloader, batchDownload, createDownloader, 
+// Publish
+PatternPublisher, submitContribution, checkContributionStatus, createPublisher, quickPublish, 
+// High-level API
+PatternStore, createPatternStore, } from './store/index.js';
+//# sourceMappingURL=index.js.map

package/dist/src/transfer/ipfs/client.d.ts

@@ -0,0 +1,109 @@
+/**
+ * IPFS Client Module
+ * Low-level IPFS operations for discovery and fetching
+ *
+ * Supports multiple gateways with automatic fallback:
+ * - Pinata (recommended for pinned content)
+ * - Cloudflare IPFS
+ * - Protocol Labs ipfs.io
+ * - dweb.link (LibP2P)
+ */
+/**
+ * Available IPFS gateways in priority order
+ */
+export declare const IPFS_GATEWAYS: string[];
+/**
+ * IPNS resolvers
+ */
+export declare const IPNS_RESOLVERS: string[];
+/**
+ * Gateway configuration
+ */
+export interface GatewayConfig {
+    url: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+    priority?: number;
+}
+/**
+ * Fetch result with metadata
+ */
+export interface FetchResult<T> {
+    data: T;
+    gateway: string;
+    cid: string;
+    cached: boolean;
+    latencyMs: number;
+}
+/**
+ * Resolve IPNS name to CID with fallback across multiple gateways
+ *
+ * @param ipnsName - IPNS key or DNSLink domain
+ * @param preferredGateway - Optional preferred gateway to try first
+ * @returns CID string or null if resolution fails
+ */
+export declare function resolveIPNS(ipnsName: string, preferredGateway?: string): Promise<string | null>;
+/**
+ * Fetch content from IPFS by CID with fallback across multiple gateways
+ *
+ * @param cid - Content Identifier
+ * @param preferredGateway - Optional preferred gateway to try first
+ * @returns Parsed JSON content or null if fetch fails
+ */
+export declare function fetchFromIPFS<T>(cid: string, preferredGateway?: string): Promise<T | null>;
+/**
+ * Fetch with full result metadata
+ */
+export declare function fetchFromIPFSWithMetadata<T>(cid: string, preferredGateway?: string): Promise<FetchResult<T> | null>;
+/**
+ * Check if CID is pinned/available on a gateway
+ */
+export declare function isPinned(cid: string, gateway?: string): Promise<boolean>;
+/**
+ * Check availability across multiple gateways
+ */
+export declare function checkAvailability(cid: string): Promise<{
+    available: boolean;
+    gateways: Array<{
+        url: string;
+        available: boolean;
+        latencyMs: number;
+    }>;
+}>;
+/**
+ * Get IPFS gateway URL for a CID
+ */
+export declare function getGatewayUrl(cid: string, gateway?: string): string;
+/**
+ * Get multiple gateway URLs for redundancy
+ */
+export declare function getGatewayUrls(cid: string): string[];
+/**
+ * Validate CID format (CIDv0 and CIDv1)
+ */
+export declare function isValidCID(cid: string): boolean;
+/**
+ * Validate IPNS name format
+ */
+export declare function isValidIPNS(ipnsName: string): boolean;
+/**
+ * Generate content hash for verification
+ */
+export declare function hashContent(content: Buffer | string): string;
+/**
+ * Verify Ed25519 signature (async import to avoid bundling issues)
+ */
+export declare function verifyEd25519Signature(message: string, signature: string, publicKey: string): Promise<boolean>;
+/**
+ * Parse CID to extract metadata
+ */
+export declare function parseCID(cid: string): {
+    version: 0 | 1;
+    codec: string;
+    hash: string;
+} | null;
+/**
+ * Format bytes to human readable
+ */
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=client.d.ts.map