kynjal-cli 4.0.0 → 4.0.1

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

@@ -2,363 +2,255 @@
  * 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
  */
-var PatternDiscovery = /** @class */ (function () {
-    function PatternDiscovery(config) {
-        if (config === void 0) { config = {}; }
-        this.config = __assign(__assign({}, DEFAULT_STORE_CONFIG), config);
+export class PatternDiscovery {
+    config;
+    cache;
+    ipnsCache;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_STORE_CONFIG, ...config };
         this.cache = new Map();
         this.ipnsCache = new Map();
     }
     /**
      * Discover and load the pattern registry
      */
-    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
-                            }];
-                }
-            });
-        });
-    };
+    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,
+        };
+    }
     /**
      * Resolve IPNS name to CID via real IPFS gateway
      */
-    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,
+    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,
                             resolvedAt: new Date().toISOString(),
-                            expiresAt: new Date(Date.now() + 3600000).toISOString()
+                            expiresAt: new Date(Date.now() + 3600000).toISOString(), // 1 hour
                         };
                         this.ipnsCache.set(ipnsName, resolution);
-                        return [2 /*return*/, resolution];
+                        console.log(`[Discovery] Resolved IPNS to CID: ${cid}`);
+                        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
      */
-    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++) {
+    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++) {
             result += base32Chars[hash[i % hash.length] % 32];
         }
         return result;
-    };
+    }
     /**
      * Fetch registry from IPFS gateway
      */
-    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)];
-                }
+    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;
+                }
+            }
+            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)
      */
-    PatternDiscovery.prototype.getGenesisRegistry = function (cid) {
+    getGenesisRegistry(cid) {
         return {
             version: '1.0.0',
             updatedAt: new Date().toISOString(),
@@ -379,7 +271,7 @@ var PatternDiscovery = /** @class */ (function () {
                         displayName: 'Claude Flow Team',
                         verified: true,
                         patterns: 1,
-                        totalDownloads: 1000
+                        totalDownloads: 1000,
                     },
                     license: 'MIT',
                     categories: ['routing', 'coordination'],
@@ -395,7 +287,7 @@ var PatternDiscovery = /** @class */ (function () {
                     verified: true,
                     trustLevel: 'verified',
                     signature: 'ed25519:genesis-pattern-signature',
-                    publicKey: 'ed25519:claude-flow-team-key'
+                    publicKey: 'ed25519:claude-flow-team-key',
                 },
             ],
             categories: [
@@ -412,7 +304,7 @@ var PatternDiscovery = /** @class */ (function () {
                     publicKey: 'ed25519:claude-flow-team-key',
                     verified: true,
                     patterns: 1,
-                    totalDownloads: 1000
+                    totalDownloads: 1000,
                 },
             ],
             totalPatterns: 1,
@@ -422,67 +314,65 @@ var PatternDiscovery = /** @class */ (function () {
             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
      */
-    PatternDiscovery.prototype.verifyRegistry = function (registry, expectedPublicKey) {
+    verifyRegistry(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
      */
-    PatternDiscovery.prototype.getCachedRegistry = function (ipnsName) {
-        var cached = this.cache.get(ipnsName);
+    getCachedRegistry(ipnsName) {
+        const cached = this.cache.get(ipnsName);
         if (cached && cached.expiresAt > Date.now()) {
             return cached.registry;
         }
         return null;
-    };
+    }
     /**
      * Cache registry
      */
-    PatternDiscovery.prototype.cacheRegistry = function (ipnsName, registry) {
+    cacheRegistry(ipnsName, registry) {
         this.cache.set(ipnsName, {
-            registry: registry,
-            expiresAt: Date.now() + this.config.cacheExpiry
+            registry,
+            expiresAt: Date.now() + this.config.cacheExpiry,
         });
-    };
+    }
     /**
      * Clear cache
      */
-    PatternDiscovery.prototype.clearCache = function () {
+    clearCache() {
         this.cache.clear();
         this.ipnsCache.clear();
-    };
+    }
     /**
      * List all known registries
      */
-    PatternDiscovery.prototype.listRegistries = function () {
+    listRegistries() {
         return this.config.registries;
-    };
+    }
     /**
      * Add a custom registry
      */
-    PatternDiscovery.prototype.addRegistry = function (registry) {
-        var existing = this.config.registries.findIndex(function (r) { return r.name === registry.name; });
+    addRegistry(registry) {
+        const existing = this.config.registries.findIndex(r => 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
  */