kynjal-cli 3.1.3 → 4.0.0

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

@@ -2,255 +2,363 @@
  * IPFS-Based Pattern Discovery
  * Secure discovery mechanism for finding patterns in decentralized environment
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import * as crypto from 'crypto';
 import { DEFAULT_STORE_CONFIG, } from './registry.js';
 /**
  * Pattern Store Discovery Service
  * Handles secure discovery of pattern registries via IPFS/IPNS
  */
-export class PatternDiscovery {
-    config;
-    cache;
-    ipnsCache;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_STORE_CONFIG, ...config };
+var PatternDiscovery = /** @class */ (function () {
+    function PatternDiscovery(config) {
+        if (config === void 0) { config = {}; }
+        this.config = __assign(__assign({}, DEFAULT_STORE_CONFIG), config);
         this.cache = new Map();
         this.ipnsCache = new Map();
     }
     /**
      * Discover and load the pattern registry
      */
-    async discoverRegistry(registryName) {
-        const targetRegistry = registryName || this.config.defaultRegistry;
-        const knownRegistry = this.config.registries.find(r => r.name === targetRegistry);
-        if (!knownRegistry) {
-            return {
-                success: false,
-                source: targetRegistry,
-                fromCache: false,
-                error: `Unknown registry: ${targetRegistry}`,
-            };
-        }
-        console.log(`[Discovery] Looking for registry: ${knownRegistry.name}`);
-        // Check cache first
-        const cached = this.getCachedRegistry(knownRegistry.ipnsName);
-        if (cached) {
-            console.log(`[Discovery] Found in cache`);
-            return {
-                success: true,
-                registry: cached,
-                source: knownRegistry.name,
-                fromCache: true,
-            };
-        }
-        // Resolve IPNS to get current CID
-        console.log(`[Discovery] Resolving IPNS: ${knownRegistry.ipnsName}`);
-        const resolution = await this.resolveIPNS(knownRegistry.ipnsName);
-        if (!resolution) {
-            return {
-                success: false,
-                source: knownRegistry.name,
-                fromCache: false,
-                error: 'Failed to resolve IPNS name',
-            };
-        }
-        // Fetch registry from IPFS
-        console.log(`[Discovery] Fetching from IPFS: ${resolution.cid}`);
-        const registry = await this.fetchRegistry(resolution.cid, knownRegistry.gateway);
-        if (!registry) {
-            return {
-                success: false,
-                source: knownRegistry.name,
-                fromCache: false,
-                cid: resolution.cid,
-                error: 'Failed to fetch registry from IPFS',
-            };
-        }
-        // Verify registry if trusted
-        if (knownRegistry.trusted && registry.registrySignature) {
-            const verified = this.verifyRegistry(registry, knownRegistry.publicKey);
-            if (!verified) {
-                console.warn(`[Discovery] Warning: Registry signature verification failed`);
-            }
-        }
-        // Cache the result
-        this.cacheRegistry(knownRegistry.ipnsName, registry);
-        return {
-            success: true,
-            registry,
-            source: knownRegistry.name,
-            fromCache: false,
-            cid: resolution.cid,
-        };
-    }
+    PatternDiscovery.prototype.discoverRegistry = function (registryName) {
+        return __awaiter(this, void 0, Promise, function () {
+            var targetRegistry, knownRegistry, cached, resolution, registry, verified;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        targetRegistry = registryName || this.config.defaultRegistry;
+                        knownRegistry = this.config.registries.find(function (r) { return r.name === targetRegistry; });
+                        if (!knownRegistry) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    source: targetRegistry,
+                                    fromCache: false,
+                                    error: "Unknown registry: " + targetRegistry
+                                }];
+                        }
+                        console.log("[Discovery] Looking for registry: " + knownRegistry.name);
+                        cached = this.getCachedRegistry(knownRegistry.ipnsName);
+                        if (cached) {
+                            console.log("[Discovery] Found in cache");
+                            return [2 /*return*/, {
+                                    success: true,
+                                    registry: cached,
+                                    source: knownRegistry.name,
+                                    fromCache: true
+                                }];
+                        }
+                        // Resolve IPNS to get current CID
+                        console.log("[Discovery] Resolving IPNS: " + knownRegistry.ipnsName);
+                        return [4 /*yield*/, this.resolveIPNS(knownRegistry.ipnsName)];
+                    case 1:
+                        resolution = _a.sent();
+                        if (!resolution) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    source: knownRegistry.name,
+                                    fromCache: false,
+                                    error: 'Failed to resolve IPNS name'
+                                }];
+                        }
+                        // Fetch registry from IPFS
+                        console.log("[Discovery] Fetching from IPFS: " + resolution.cid);
+                        return [4 /*yield*/, this.fetchRegistry(resolution.cid, knownRegistry.gateway)];
+                    case 2:
+                        registry = _a.sent();
+                        if (!registry) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    source: knownRegistry.name,
+                                    fromCache: false,
+                                    cid: resolution.cid,
+                                    error: 'Failed to fetch registry from IPFS'
+                                }];
+                        }
+                        // Verify registry if trusted
+                        if (knownRegistry.trusted && registry.registrySignature) {
+                            verified = this.verifyRegistry(registry, knownRegistry.publicKey);
+                            if (!verified) {
+                                console.warn("[Discovery] Warning: Registry signature verification failed");
+                            }
+                        }
+                        // Cache the result
+                        this.cacheRegistry(knownRegistry.ipnsName, registry);
+                        return [2 /*return*/, {
+                                success: true,
+                                registry: registry,
+                                source: knownRegistry.name,
+                                fromCache: false,
+                                cid: resolution.cid
+                            }];
+                }
+            });
+        });
+    };
     /**
      * Resolve IPNS name to CID via real IPFS gateway
      */
-    async resolveIPNS(ipnsName) {
-        // Check cache
-        const cached = this.ipnsCache.get(ipnsName);
-        if (cached && new Date(cached.expiresAt) > new Date()) {
-            return cached;
-        }
-        const gateways = [
-            'https://ipfs.io',
-            'https://dweb.link',
-            'https://cloudflare-ipfs.com',
-        ];
-        for (const gateway of gateways) {
-            try {
-                console.log(`[Discovery] Resolving IPNS via ${gateway}...`);
-                // Try IPNS resolution endpoint
-                const response = await fetch(`${gateway}/api/v0/name/resolve?arg=${ipnsName}`, {
-                    method: 'POST',
-                    signal: AbortSignal.timeout(10000),
-                });
-                if (response.ok) {
-                    const data = await response.json();
-                    const cid = data.Path?.replace('/ipfs/', '') || '';
-                    if (cid) {
-                        const resolution = {
-                            ipnsName,
-                            cid,
+    PatternDiscovery.prototype.resolveIPNS = function (ipnsName) {
+        var _a;
+        return __awaiter(this, void 0, Promise, function () {
+            var cached, gateways, _i, gateways_1, gateway, response, data, cid, resolution_1, ipnsResponse, finalUrl, cidMatch, cid, resolution_2, error_1, fallbackCid, resolution;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        cached = this.ipnsCache.get(ipnsName);
+                        if (cached && new Date(cached.expiresAt) > new Date()) {
+                            return [2 /*return*/, cached];
+                        }
+                        gateways = [
+                            'https://ipfs.io',
+                            'https://dweb.link',
+                            'https://cloudflare-ipfs.com',
+                        ];
+                        _i = 0, gateways_1 = gateways;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < gateways_1.length)) return [3 /*break*/, 9];
+                        gateway = gateways_1[_i];
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 7, , 8]);
+                        console.log("[Discovery] Resolving IPNS via " + gateway + "...");
+                        return [4 /*yield*/, fetch(gateway + "/api/v0/name/resolve?arg=" + ipnsName, {
+                                method: 'POST',
+                                signal: AbortSignal.timeout(10000)
+                            })];
+                    case 3:
+                        response = _b.sent();
+                        if (!response.ok) return [3 /*break*/, 5];
+                        return [4 /*yield*/, response.json()];
+                    case 4:
+                        data = _b.sent();
+                        cid = ((_a = data.Path) === null || _a === void 0 ? void 0 : _a.replace('/ipfs/', '')) || '';
+                        if (cid) {
+                            resolution_1 = {
+                                ipnsName: ipnsName,
+                                cid: cid,
+                                resolvedAt: new Date().toISOString(),
+                                expiresAt: new Date(Date.now() + 3600000).toISOString()
+                            };
+                            this.ipnsCache.set(ipnsName, resolution_1);
+                            console.log("[Discovery] Resolved IPNS to CID: " + cid);
+                            return [2 /*return*/, resolution_1];
+                        }
+                        _b.label = 5;
+                    case 5: return [4 /*yield*/, fetch(gateway + "/ipns/" + ipnsName, {
+                            method: 'HEAD',
+                            signal: AbortSignal.timeout(10000),
+                            redirect: 'follow'
+                        })];
+                    case 6:
+                        ipnsResponse = _b.sent();
+                        if (ipnsResponse.ok) {
+                            finalUrl = ipnsResponse.url;
+                            cidMatch = finalUrl.match(/\/ipfs\/([a-zA-Z0-9]+)/);
+                            if (cidMatch) {
+                                cid = cidMatch[1];
+                                resolution_2 = {
+                                    ipnsName: ipnsName,
+                                    cid: cid,
+                                    resolvedAt: new Date().toISOString(),
+                                    expiresAt: new Date(Date.now() + 3600000).toISOString()
+                                };
+                                this.ipnsCache.set(ipnsName, resolution_2);
+                                console.log("[Discovery] Resolved IPNS via redirect to CID: " + cid);
+                                return [2 /*return*/, resolution_2];
+                            }
+                        }
+                        return [3 /*break*/, 8];
+                    case 7:
+                        error_1 = _b.sent();
+                        console.warn("[Discovery] IPNS resolution via " + gateway + " failed:", error_1);
+                        return [3 /*break*/, 8];
+                    case 8:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 9:
+                        // Fallback: Generate deterministic CID for well-known registries
+                        console.warn("\u26A0 [Discovery] OFFLINE MODE - Could not resolve IPNS: " + ipnsName);
+                        console.warn("\u26A0 [Discovery] Using built-in fallback registry (may be outdated)");
+                        fallbackCid = this.generateFallbackCID(ipnsName);
+                        resolution = {
+                            ipnsName: ipnsName,
+                            cid: fallbackCid,
                             resolvedAt: new Date().toISOString(),
-                            expiresAt: new Date(Date.now() + 3600000).toISOString(), // 1 hour
+                            expiresAt: new Date(Date.now() + 3600000).toISOString()
                         };
                         this.ipnsCache.set(ipnsName, resolution);
-                        console.log(`[Discovery] Resolved IPNS to CID: ${cid}`);
-                        return resolution;
-                    }
+                        return [2 /*return*/, resolution];
                 }
-                // Fallback: Try fetching content directly via IPNS gateway URL
-                const ipnsResponse = await fetch(`${gateway}/ipns/${ipnsName}`, {
-                    method: 'HEAD',
-                    signal: AbortSignal.timeout(10000),
-                    redirect: 'follow',
-                });
-                if (ipnsResponse.ok) {
-                    // Extract CID from final URL if redirected
-                    const finalUrl = ipnsResponse.url;
-                    const cidMatch = finalUrl.match(/\/ipfs\/([a-zA-Z0-9]+)/);
-                    if (cidMatch) {
-                        const cid = cidMatch[1];
-                        const resolution = {
-                            ipnsName,
-                            cid,
-                            resolvedAt: new Date().toISOString(),
-                            expiresAt: new Date(Date.now() + 3600000).toISOString(),
-                        };
-                        this.ipnsCache.set(ipnsName, resolution);
-                        console.log(`[Discovery] Resolved IPNS via redirect to CID: ${cid}`);
-                        return resolution;
-                    }
-                }
-            }
-            catch (error) {
-                console.warn(`[Discovery] IPNS resolution via ${gateway} failed:`, error);
-                // Continue to next gateway
-            }
-        }
-        // Fallback: Generate deterministic CID for well-known registries
-        console.warn(`⚠ [Discovery] OFFLINE MODE - Could not resolve IPNS: ${ipnsName}`);
-        console.warn(`⚠ [Discovery] Using built-in fallback registry (may be outdated)`);
-        const fallbackCid = this.generateFallbackCID(ipnsName);
-        const resolution = {
-            ipnsName,
-            cid: fallbackCid,
-            resolvedAt: new Date().toISOString(),
-            expiresAt: new Date(Date.now() + 3600000).toISOString(),
-        };
-        this.ipnsCache.set(ipnsName, resolution);
-        return resolution;
-    }
+            });
+        });
+    };
     /**
      * Generate deterministic fallback CID for offline/demo mode
      */
-    generateFallbackCID(input) {
-        const hash = crypto.createHash('sha256').update(input + 'registry').digest();
-        const prefix = 'bafybei';
-        const base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
-        let result = prefix;
-        for (let i = 0; i < 44; i++) {
+    PatternDiscovery.prototype.generateFallbackCID = function (input) {
+        var hash = crypto.createHash('sha256').update(input + 'registry').digest();
+        var prefix = 'bafybei';
+        var base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
+        var result = prefix;
+        for (var i = 0; i < 44; i++) {
             result += base32Chars[hash[i % hash.length] % 32];
         }
         return result;
-    }
+    };
     /**
      * Fetch registry from IPFS gateway
      */
-    async fetchRegistry(cid, gateway) {
-        const url = `${gateway}/ipfs/${cid}`;
-        console.log(`[Discovery] Fetching: ${url}`);
-        try {
-            const response = await fetch(url, {
-                signal: AbortSignal.timeout(30000),
-            });
-            if (response.ok) {
-                const text = await response.text();
-                try {
-                    const registry = JSON.parse(text);
-                    console.log(`[Discovery] Fetched registry with ${registry.patterns?.length || 0} patterns`);
-                    return registry;
-                }
-                catch {
-                    console.error(`[Discovery] Invalid registry JSON`);
-                }
-            }
-        }
-        catch (error) {
-            console.warn(`[Discovery] Fetch from ${gateway} failed:`, error);
-        }
-        // Try alternative gateways
-        const alternativeGateways = [
-            'https://ipfs.io',
-            'https://dweb.link',
-            'https://cloudflare-ipfs.com',
-            'https://gateway.pinata.cloud',
-        ];
-        for (const altGateway of alternativeGateways) {
-            if (altGateway === gateway)
-                continue;
-            try {
-                const altUrl = `${altGateway}/ipfs/${cid}`;
-                console.log(`[Discovery] Trying alternative: ${altUrl}`);
-                const response = await fetch(altUrl, {
-                    signal: AbortSignal.timeout(15000),
-                });
-                if (response.ok) {
-                    const registry = await response.json();
-                    console.log(`[Discovery] Fetched registry from ${altGateway}`);
-                    return registry;
+    PatternDiscovery.prototype.fetchRegistry = function (cid, gateway) {
+        var _a;
+        return __awaiter(this, void 0, Promise, function () {
+            var url, response, text, registry, error_2, alternativeGateways, _i, alternativeGateways_1, altGateway, altUrl, response, registry, _b, _c, hasGCSCredentials, downloadFromGCS, gcsUri, buffer, registry, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        url = gateway + "/ipfs/" + cid;
+                        console.log("[Discovery] Fetching: " + url);
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 5, , 6]);
+                        return [4 /*yield*/, fetch(url, {
+                                signal: AbortSignal.timeout(30000)
+                            })];
+                    case 2:
+                        response = _e.sent();
+                        if (!response.ok) return [3 /*break*/, 4];
+                        return [4 /*yield*/, response.text()];
+                    case 3:
+                        text = _e.sent();
+                        try {
+                            registry = JSON.parse(text);
+                            console.log("[Discovery] Fetched registry with " + (((_a = registry.patterns) === null || _a === void 0 ? void 0 : _a.length) || 0) + " patterns");
+                            return [2 /*return*/, registry];
+                        }
+                        catch (_f) {
+                            console.error("[Discovery] Invalid registry JSON");
+                        }
+                        _e.label = 4;
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        error_2 = _e.sent();
+                        console.warn("[Discovery] Fetch from " + gateway + " failed:", error_2);
+                        return [3 /*break*/, 6];
+                    case 6:
+                        alternativeGateways = [
+                            'https://ipfs.io',
+                            'https://dweb.link',
+                            'https://cloudflare-ipfs.com',
+                            'https://gateway.pinata.cloud',
+                        ];
+                        _i = 0, alternativeGateways_1 = alternativeGateways;
+                        _e.label = 7;
+                    case 7:
+                        if (!(_i < alternativeGateways_1.length)) return [3 /*break*/, 14];
+                        altGateway = alternativeGateways_1[_i];
+                        if (altGateway === gateway)
+                            return [3 /*break*/, 13];
+                        _e.label = 8;
+                    case 8:
+                        _e.trys.push([8, 12, , 13]);
+                        altUrl = altGateway + "/ipfs/" + cid;
+                        console.log("[Discovery] Trying alternative: " + altUrl);
+                        return [4 /*yield*/, fetch(altUrl, {
+                                signal: AbortSignal.timeout(15000)
+                            })];
+                    case 9:
+                        response = _e.sent();
+                        if (!response.ok) return [3 /*break*/, 11];
+                        return [4 /*yield*/, response.json()];
+                    case 10:
+                        registry = _e.sent();
+                        console.log("[Discovery] Fetched registry from " + altGateway);
+                        return [2 /*return*/, registry];
+                    case 11: return [3 /*break*/, 13];
+                    case 12:
+                        _b = _e.sent();
+                        return [3 /*break*/, 13];
+                    case 13:
+                        _i++;
+                        return [3 /*break*/, 7];
+                    case 14:
+                        _e.trys.push([14, 18, , 19]);
+                        return [4 /*yield*/, import('../storage/gcs.js')];
+                    case 15:
+                        _c = _e.sent(), hasGCSCredentials = _c.hasGCSCredentials, downloadFromGCS = _c.downloadFromGCS;
+                        if (!hasGCSCredentials()) return [3 /*break*/, 17];
+                        gcsUri = "gs://claude-flow-patterns/registry/" + cid + ".json";
+                        console.log("[Discovery] Trying GCS: " + gcsUri);
+                        return [4 /*yield*/, downloadFromGCS(gcsUri)];
+                    case 16:
+                        buffer = _e.sent();
+                        if (buffer) {
+                            registry = JSON.parse(buffer.toString());
+                            console.log("[Discovery] Fetched registry from GCS");
+                            return [2 /*return*/, registry];
+                        }
+                        _e.label = 17;
+                    case 17: return [3 /*break*/, 19];
+                    case 18:
+                        _d = _e.sent();
+                        return [3 /*break*/, 19];
+                    case 19:
+                        // Return fallback genesis registry if all else fails
+                        console.log("[Discovery] Using built-in genesis registry");
+                        return [2 /*return*/, this.getGenesisRegistry(cid)];
                 }
-            }
-            catch {
-                // Continue to next gateway
-            }
-        }
-        // Check for GCS-hosted registry
-        try {
-            const { hasGCSCredentials, downloadFromGCS } = await import('../storage/gcs.js');
-            if (hasGCSCredentials()) {
-                const gcsUri = `gs://claude-flow-patterns/registry/${cid}.json`;
-                console.log(`[Discovery] Trying GCS: ${gcsUri}`);
-                const buffer = await downloadFromGCS(gcsUri);
-                if (buffer) {
-                    const registry = JSON.parse(buffer.toString());
-                    console.log(`[Discovery] Fetched registry from GCS`);
-                    return registry;
-                }
-            }
-        }
-        catch {
-            // GCS not available
-        }
-        // Return fallback genesis registry if all else fails
-        console.log(`[Discovery] Using built-in genesis registry`);
-        return this.getGenesisRegistry(cid);
-    }
+            });
+        });
+    };
     /**
      * Get built-in genesis registry (always available offline)
      */
-    getGenesisRegistry(cid) {
+    PatternDiscovery.prototype.getGenesisRegistry = function (cid) {
         return {
             version: '1.0.0',
             updatedAt: new Date().toISOString(),
@@ -261,23 +369,23 @@ export class PatternDiscovery {
                     id: 'seraphine-genesis-v1',
                     name: 'seraphine-genesis',
                     displayName: 'Seraphine Genesis',
-                    description: 'The foundational KynjalFlow pattern model. Contains core routing patterns, complexity heuristics, and coordination trajectories for multi-agent swarms.',
+                    description: 'The foundational Claude Flow pattern model. Contains core routing patterns, complexity heuristics, and coordination trajectories for multi-agent swarms.',
                     version: '1.0.0',
                     cid: 'bafybeibqsa442vty2cvhku4ujlrkupyl75536ene7ybqsa442v',
                     size: 8808,
                     checksum: '8df766b89d044815c84796e7f33ba30d7806bff7eb2a75e2a0b7d26b64c45231',
                     author: {
                         id: 'claude-flow-team',
-                        displayName: 'KynjalFlow Team',
+                        displayName: 'Claude Flow Team',
                         verified: true,
                         patterns: 1,
-                        totalDownloads: 1000,
+                        totalDownloads: 1000
                     },
                     license: 'MIT',
                     categories: ['routing', 'coordination'],
                     tags: ['genesis', 'foundational', 'routing', 'swarm', 'coordination', 'multi-agent', 'hello-world'],
                     language: 'typescript',
-                    framework: 'kynjalflow',
+                    framework: 'claude-flow',
                     downloads: 1000,
                     rating: 5.0,
                     ratingCount: 42,
@@ -287,7 +395,7 @@ export class PatternDiscovery {
                     verified: true,
                     trustLevel: 'verified',
                     signature: 'ed25519:genesis-pattern-signature',
-                    publicKey: 'ed25519:claude-flow-team-key',
+                    publicKey: 'ed25519:claude-flow-team-key'
                 },
             ],
             categories: [
@@ -300,11 +408,11 @@ export class PatternDiscovery {
             authors: [
                 {
                     id: 'claude-flow-team',
-                    displayName: 'KynjalFlow Team',
+                    displayName: 'Claude Flow Team',
                     publicKey: 'ed25519:claude-flow-team-key',
                     verified: true,
                     patterns: 1,
-                    totalDownloads: 1000,
+                    totalDownloads: 1000
                 },
             ],
             totalPatterns: 1,
@@ -314,65 +422,67 @@ export class PatternDiscovery {
             trending: ['seraphine-genesis-v1'],
             newest: ['seraphine-genesis-v1'],
             registrySignature: crypto.randomBytes(32).toString('hex'),
-            registryPublicKey: 'ed25519:claude-flow-registry-key',
+            registryPublicKey: 'ed25519:claude-flow-registry-key'
         };
-    }
+    };
     /**
      * Verify registry signature
      */
-    verifyRegistry(registry, expectedPublicKey) {
+    PatternDiscovery.prototype.verifyRegistry = function (registry, expectedPublicKey) {
         if (!registry.registrySignature) {
             return false;
         }
         // In production: Actual Ed25519 verification
         // For demo: Check signature length
         return registry.registrySignature.length === 64;
-    }
+    };
     /**
      * Get cached registry
      */
-    getCachedRegistry(ipnsName) {
-        const cached = this.cache.get(ipnsName);
+    PatternDiscovery.prototype.getCachedRegistry = function (ipnsName) {
+        var cached = this.cache.get(ipnsName);
         if (cached && cached.expiresAt > Date.now()) {
             return cached.registry;
         }
         return null;
-    }
+    };
     /**
      * Cache registry
      */
-    cacheRegistry(ipnsName, registry) {
+    PatternDiscovery.prototype.cacheRegistry = function (ipnsName, registry) {
         this.cache.set(ipnsName, {
-            registry,
-            expiresAt: Date.now() + this.config.cacheExpiry,
+            registry: registry,
+            expiresAt: Date.now() + this.config.cacheExpiry
         });
-    }
+    };
     /**
      * Clear cache
      */
-    clearCache() {
+    PatternDiscovery.prototype.clearCache = function () {
         this.cache.clear();
         this.ipnsCache.clear();
-    }
+    };
     /**
      * List all known registries
      */
-    listRegistries() {
+    PatternDiscovery.prototype.listRegistries = function () {
         return this.config.registries;
-    }
+    };
     /**
      * Add a custom registry
      */
-    addRegistry(registry) {
-        const existing = this.config.registries.findIndex(r => r.name === registry.name);
+    PatternDiscovery.prototype.addRegistry = function (registry) {
+        var existing = this.config.registries.findIndex(function (r) { return r.name === registry.name; });
         if (existing >= 0) {
             this.config.registries[existing] = registry;
         }
         else {
             this.config.registries.push(registry);
         }
-    }
-}
+    };
+    return PatternDiscovery;
+}());
+export { PatternDiscovery };
 /**
  * Create discovery service with default config
  */