@cloudpftc/opencode-orchestrator 3.5.15

package/v3/@claude-flow/cli/dist/src/transfer/test-seraphine.js

@@ -0,0 +1,105 @@
+/**
+ * Test Seraphine Genesis Model
+ * Quick validation of the transfer pipeline
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Simple test without complex imports
+async function test() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════╗');
+    console.log('║           SERAPHINE GENESIS TEST SUITE                    ║');
+    console.log('╚══════════════════════════════════════════════════════════╝');
+    console.log('');
+    let passed = 0;
+    let failed = 0;
+    // Test 1: Types file exists
+    const typesPath = path.join(__dirname, 'types.ts');
+    if (fs.existsSync(typesPath)) {
+        console.log('✅ Test 1: Types module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 1: Types module missing');
+        failed++;
+    }
+    // Test 2: Seraphine model exists
+    const seraphPath = path.join(__dirname, 'models', 'seraphine.ts');
+    if (fs.existsSync(seraphPath)) {
+        console.log('✅ Test 2: Seraphine model exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 2: Seraphine model missing');
+        failed++;
+    }
+    // Test 3: CFP serializer exists
+    const cfpPath = path.join(__dirname, 'serialization', 'cfp.ts');
+    if (fs.existsSync(cfpPath)) {
+        console.log('✅ Test 3: CFP serializer exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 3: CFP serializer missing');
+        failed++;
+    }
+    // Test 4: Anonymization module exists
+    const anonPath = path.join(__dirname, 'anonymization', 'index.ts');
+    if (fs.existsSync(anonPath)) {
+        console.log('✅ Test 4: Anonymization module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 4: Anonymization module missing');
+        failed++;
+    }
+    // Test 5: IPFS upload module exists
+    const ipfsPath = path.join(__dirname, 'ipfs', 'upload.ts');
+    if (fs.existsSync(ipfsPath)) {
+        console.log('✅ Test 5: IPFS upload module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 5: IPFS upload module missing');
+        failed++;
+    }
+    // Test 6: Export module exists
+    const exportPath = path.join(__dirname, 'export.ts');
+    if (fs.existsSync(exportPath)) {
+        console.log('✅ Test 6: Export module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 6: Export module missing');
+        failed++;
+    }
+    // Test 7: Index module exists
+    const indexPath = path.join(__dirname, 'index.ts');
+    if (fs.existsSync(indexPath)) {
+        console.log('✅ Test 7: Index module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 7: Index module missing');
+        failed++;
+    }
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log(`   Results: ${passed} passed, ${failed} failed`);
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('');
+    if (failed === 0) {
+        console.log('🎉 All module tests passed!');
+        console.log('');
+        console.log('Next steps:');
+        console.log('  1. Compile TypeScript: cd v3/@claude-flow/cli && npm run build');
+        console.log('  2. Run deployment: npx ts-node src/transfer/deploy-seraphine.ts --to-ipfs');
+        console.log('');
+    }
+    process.exit(failed > 0 ? 1 : 0);
+}
+test().catch(console.error);
+//# sourceMappingURL=test-seraphine.js.map

package/v3/@claude-flow/cli/dist/src/transfer/tests/test-store.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env npx tsx
+/**
+ * Pattern Store Test Suite
+ * Tests list, search, download, and publish functionality
+ */
+export {};
+//# sourceMappingURL=test-store.d.ts.map

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

@@ -0,0 +1,214 @@
+#!/usr/bin/env npx tsx
+/**
+ * Pattern Store Test Suite
+ * Tests list, search, download, and publish functionality
+ */
+import { createDiscoveryService } from '../store/discovery.js';
+import { searchPatterns, getSearchSuggestions, getTagCloud } from '../store/search.js';
+import { createDownloader } from '../store/download.js';
+import { createPublisher } from '../store/publish.js';
+import { createSeraphineGenesis } from '../models/seraphine.js';
+// Test results tracking
+const results = [];
+function logTest(name, passed, details) {
+    results.push({ test: name, passed, details });
+    const icon = passed ? '✅' : '❌';
+    console.log(`${icon} ${name}${details ? `: ${details}` : ''}`);
+}
+async function runTests() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════╗');
+    console.log('║        PATTERN STORE TEST SUITE                          ║');
+    console.log('║        Testing List, Search, Download, Publish           ║');
+    console.log('╚══════════════════════════════════════════════════════════╝');
+    console.log('');
+    // ==========================================================================
+    // 1. DISCOVERY TESTS
+    // ==========================================================================
+    console.log('─── Discovery Tests ───────────────────────────────────────');
+    try {
+        const discovery = createDiscoveryService();
+        logTest('Discovery service created', true);
+        // List registries
+        const registries = discovery.listRegistries();
+        logTest('List registries', registries.length > 0, `Found ${registries.length} registries`);
+        // Discover registry
+        const result = await discovery.discoverRegistry();
+        logTest('Discover registry', result.success, result.success
+            ? `Loaded ${result.registry?.patterns.length || 0} patterns`
+            : result.error);
+        // Cache test
+        if (result.success) {
+            const cachedResult = await discovery.discoverRegistry();
+            logTest('Cache hit', cachedResult.fromCache, 'Second request from cache');
+        }
+        console.log('');
+        // ==========================================================================
+        // 2. SEARCH TESTS
+        // ==========================================================================
+        console.log('─── Search Tests ──────────────────────────────────────────');
+        if (result.success && result.registry) {
+            const registry = result.registry;
+            // Basic search
+            const basicSearch = searchPatterns(registry);
+            logTest('Basic search', basicSearch.patterns.length > 0, `Found ${basicSearch.total} patterns`);
+            // Query search
+            const querySearch = searchPatterns(registry, { query: 'routing' });
+            logTest('Query search', true, `Query "routing" found ${querySearch.patterns.length} patterns`);
+            // Category filter
+            const categorySearch = searchPatterns(registry, { category: 'routing' });
+            logTest('Category filter', true, `Category "routing" found ${categorySearch.patterns.length} patterns`);
+            // Tag search
+            const tagSearch = searchPatterns(registry, { tags: ['genesis'] });
+            logTest('Tag search', true, `Tag "genesis" found ${tagSearch.patterns.length} patterns`);
+            // Verified filter
+            const verifiedSearch = searchPatterns(registry, { verified: true });
+            logTest('Verified filter', true, `Verified patterns: ${verifiedSearch.patterns.length}`);
+            // Sort by downloads
+            const sortedSearch = searchPatterns(registry, {
+                sortBy: 'downloads',
+                sortOrder: 'desc',
+            });
+            logTest('Sort by downloads', true, `Top pattern: ${sortedSearch.patterns[0]?.displayName || 'none'}`);
+            // Pagination
+            const page1 = searchPatterns(registry, { limit: 5, offset: 0 });
+            logTest('Pagination', page1.pageSize === 5, `Page 1 with ${page1.patterns.length} patterns, hasMore: ${page1.hasMore}`);
+            // Search suggestions
+            const suggestions = getSearchSuggestions(registry, 'rou');
+            logTest('Search suggestions', suggestions.length >= 0, `Suggestions for "rou": ${suggestions.slice(0, 3).join(', ')}`);
+            // Tag cloud
+            const tagCloud = getTagCloud(registry);
+            logTest('Tag cloud', tagCloud.size > 0, `${tagCloud.size} unique tags`);
+        }
+        console.log('');
+        // ==========================================================================
+        // 3. DOWNLOAD TESTS
+        // ==========================================================================
+        console.log('─── Download Tests ────────────────────────────────────────');
+        if (result.success && result.registry && result.registry.patterns.length > 0) {
+            const pattern = result.registry.patterns[0];
+            const downloader = createDownloader();
+            logTest('Downloader created', true);
+            // Download with progress
+            let progressCalled = false;
+            const downloadResult = await downloader.downloadPattern(pattern, {
+                verify: true,
+            }, (progress) => {
+                progressCalled = true;
+            });
+            logTest('Download pattern', downloadResult.success, downloadResult.success
+                ? `Downloaded ${downloadResult.size} bytes`
+                : 'Failed');
+            logTest('Progress callback', progressCalled, progressCalled ? 'Progress events received' : 'No progress events');
+            logTest('Checksum verification', downloadResult.verified !== undefined, `Verified: ${downloadResult.verified}`);
+            // Cache stats
+            const cacheStats = downloader.getCacheStats();
+            logTest('Cache statistics', cacheStats.count >= 0, `${cacheStats.count} items, ${cacheStats.totalSize} bytes`);
+        }
+        console.log('');
+        // ==========================================================================
+        // 4. PUBLISH TESTS
+        // ==========================================================================
+        console.log('─── Publish Tests ─────────────────────────────────────────');
+        const cfp = createSeraphineGenesis();
+        const publisher = createPublisher();
+        logTest('Publisher created', true);
+        // Validation
+        const validation = publisher.validateForPublish(cfp, {
+            name: 'test-pattern',
+            displayName: 'Test Pattern',
+            description: 'A test pattern for validation',
+            categories: ['testing'],
+            tags: ['test', 'validation', 'demo'],
+            license: 'MIT',
+            anonymize: 'standard',
+        });
+        logTest('Publish validation', validation.length === 0, validation.length === 0 ? 'All validations passed' : validation.join(', '));
+        // Preview
+        const preview = publisher.createPreview(cfp, {
+            name: 'seraphine-genesis',
+            displayName: 'Seraphine Genesis',
+            description: 'The foundational pattern model',
+            categories: ['routing', 'coordination'],
+            tags: ['genesis', 'foundational'],
+            license: 'MIT',
+            anonymize: 'standard',
+        });
+        logTest('Publish preview', preview !== null, `Preview created for ${preview.name}`);
+        // Publish (mock)
+        const publishResult = await publisher.publishPattern(cfp, {
+            name: 'test-pattern',
+            displayName: 'Test Pattern',
+            description: 'A test pattern published to IPFS',
+            categories: ['testing'],
+            tags: ['test', 'demo', 'hello-world'],
+            license: 'MIT',
+            anonymize: 'standard',
+        });
+        logTest('Publish to IPFS', publishResult.success, publishResult.success
+            ? `CID: ${publishResult.cid.slice(0, 20)}...`
+            : publishResult.message);
+        console.log('');
+        // ==========================================================================
+        // 5. INTEGRATION TEST
+        // ==========================================================================
+        console.log('─── Integration Test ──────────────────────────────────────');
+        // Full workflow: discover -> search -> download
+        const store = createDiscoveryService();
+        const discoverResult = await store.discoverRegistry();
+        if (discoverResult.success && discoverResult.registry) {
+            const searchResult = searchPatterns(discoverResult.registry, {
+                query: 'seraphine',
+            });
+            if (searchResult.patterns.length > 0) {
+                const dl = createDownloader();
+                const dlResult = await dl.downloadPattern(searchResult.patterns[0], {
+                    verify: true,
+                });
+                logTest('Full workflow', dlResult.success, 'Discover → Search → Download completed');
+            }
+            else {
+                logTest('Full workflow', true, 'Discover → Search completed (no download)');
+            }
+        }
+    }
+    catch (error) {
+        console.error('Test error:', error);
+        logTest('Test suite', false, `Error: ${error}`);
+    }
+    // ==========================================================================
+    // SUMMARY
+    // ==========================================================================
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('                      TEST SUMMARY                          ');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('');
+    const passed = results.filter(r => r.passed).length;
+    const failed = results.filter(r => !r.passed).length;
+    const total = results.length;
+    console.log(`   Total Tests: ${total}`);
+    console.log(`   ✅ Passed: ${passed}`);
+    console.log(`   ❌ Failed: ${failed}`);
+    console.log('');
+    if (failed === 0) {
+        console.log('   🎉 All tests passed!');
+        console.log('');
+        console.log('   📦 Store Features Verified:');
+        console.log('      - Registry discovery via IPNS');
+        console.log('      - Pattern search with filters');
+        console.log('      - Download with verification');
+        console.log('      - Publish with anonymization');
+        console.log('');
+    }
+    else {
+        console.log('   ⚠️ Some tests failed. Please review the output above.');
+    }
+    process.exit(failed > 0 ? 1 : 0);
+}
+// Run tests
+runTests().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=test-store.js.map

package/v3/@claude-flow/cli/dist/src/transfer/types.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Transfer Hook Types
+ * Core type definitions for pattern export/import and IPFS sharing
+ */
+export type AnonymizationLevel = 'minimal' | 'standard' | 'strict' | 'paranoid';
+export type SerializationFormat = 'cbor' | 'json' | 'msgpack' | 'cbor.gz' | 'cbor.zstd';
+export type PatternType = 'routing' | 'complexity' | 'coverage' | 'trajectory' | 'custom';
+export type ImportStrategy = 'replace' | 'merge' | 'append';
+export type ConflictResolution = 'highest-confidence' | 'newest' | 'oldest' | 'keep-local' | 'keep-remote';
+export type TrustLevel = 'official' | 'verified' | 'community' | 'unverified' | 'untrusted';
+export type PinningService = 'local' | 'pinata' | 'web3storage' | 'infura' | 'custom';
+/**
+ * Pattern metadata
+ */
+export interface PatternMetadata {
+    id: string;
+    name?: string;
+    description?: string;
+    author?: AnonymizedAuthor;
+    license?: string;
+    tags: string[];
+    language?: string;
+    framework?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Anonymized author info
+ */
+export interface AnonymizedAuthor {
+    id: string;
+    displayName?: string;
+    verified: boolean;
+}
+/**
+ * Anonymization record
+ */
+export interface AnonymizationRecord {
+    level: AnonymizationLevel;
+    appliedTransforms: string[];
+    piiRedacted: boolean;
+    pathsStripped: boolean;
+    timestampsGeneralized: boolean;
+    checksum: string;
+}
+/**
+ * Routing pattern
+ */
+export interface RoutingPattern {
+    id: string;
+    trigger: string;
+    action: string;
+    confidence: number;
+    usageCount: number;
+    successRate: number;
+    context?: Record<string, unknown>;
+}
+/**
+ * Complexity pattern
+ */
+export interface ComplexityPattern {
+    id: string;
+    pattern: string;
+    complexity: number;
+    tokens: number;
+    frequency: number;
+}
+/**
+ * Coverage pattern
+ */
+export interface CoveragePattern {
+    id: string;
+    domain: string;
+    coverage: number;
+    gaps: string[];
+}
+/**
+ * Trajectory pattern
+ */
+export interface TrajectoryPattern {
+    id: string;
+    steps: string[];
+    outcome: 'success' | 'failure' | 'partial';
+    duration: number;
+    learnings: string[];
+}
+/**
+ * Custom pattern
+ */
+export interface CustomPattern {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+}
+/**
+ * Pattern collection
+ */
+export interface PatternCollection {
+    routing: RoutingPattern[];
+    complexity: ComplexityPattern[];
+    coverage: CoveragePattern[];
+    trajectory: TrajectoryPattern[];
+    custom: CustomPattern[];
+}
+/**
+ * Statistics with differential privacy
+ */
+export interface PatternStatistics {
+    totalPatterns: number;
+    avgConfidence: number;
+    patternTypes: Record<string, number>;
+    timeRange: {
+        start: string;
+        end: string;
+    };
+}
+/**
+ * Ed25519 signature
+ */
+export interface PatternSignature {
+    algorithm: 'ed25519';
+    publicKey: string;
+    signature: string;
+}
+/**
+ * IPFS metadata
+ */
+export interface IPFSMetadata {
+    cid: string;
+    pinnedAt: string[];
+    gateway: string;
+    size: number;
+}
+/**
+ * Claude Flow Pattern (CFP) format
+ */
+export interface CFPFormat {
+    magic: 'CFP1';
+    version: string;
+    createdAt: string;
+    generatedBy: string;
+    metadata: PatternMetadata;
+    anonymization: AnonymizationRecord;
+    patterns: PatternCollection;
+    statistics: PatternStatistics;
+    signature?: PatternSignature;
+    ipfs?: IPFSMetadata;
+}
+/**
+ * Export options
+ */
+export interface ExportOptions {
+    output?: string;
+    format?: SerializationFormat;
+    anonymize?: AnonymizationLevel;
+    redactPii?: boolean;
+    stripPaths?: boolean;
+    types?: PatternType[];
+    minConfidence?: number;
+    since?: string;
+    toIpfs?: boolean;
+    pin?: boolean;
+    gateway?: string;
+    sign?: boolean;
+    privateKeyPath?: string;
+}
+/**
+ * Import options
+ */
+export interface ImportOptions {
+    input?: string;
+    fromIpfs?: string;
+    fromStore?: string;
+    version?: string;
+    strategy?: ImportStrategy;
+    conflictResolution?: ConflictResolution;
+    verifySignature?: boolean;
+    dryRun?: boolean;
+}
+/**
+ * Export result
+ */
+export interface ExportResult {
+    success: boolean;
+    outputPath?: string;
+    cid?: string;
+    gateway?: string;
+    size: number;
+    patternCount: number;
+    anonymizationLevel: AnonymizationLevel;
+    signature?: string;
+}
+/**
+ * Import result
+ */
+export interface ImportResult {
+    success: boolean;
+    imported: number;
+    skipped: number;
+    conflicts: number;
+    source: string;
+    verified: boolean;
+}
+/**
+ * IPFS config
+ */
+export interface IPFSConfig {
+    gateway: string;
+    apiEndpoint?: string;
+    pinningService?: {
+        name: PinningService;
+        apiKey: string;
+        apiSecret?: string;
+    };
+    timeout: number;
+}
+/**
+ * PII detection result
+ */
+export interface PIIDetectionResult {
+    found: boolean;
+    count: number;
+    types: Record<string, number>;
+    locations: Array<{
+        type: string;
+        path: string;
+        sample: string;
+        severity: 'low' | 'medium' | 'high' | 'critical';
+    }>;
+}
+/**
+ * Verification result
+ */
+export interface VerificationResult {
+    valid: boolean;
+    signatureValid?: boolean;
+    checksumValid: boolean;
+    malwareCheck?: {
+        safe: boolean;
+        warnings: string[];
+    };
+    trustLevel: TrustLevel;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,6 @@
+/**
+ * Transfer Hook Types
+ * Core type definitions for pattern export/import and IPFS sharing
+ */
+export {};
+//# sourceMappingURL=types.js.map