kynjal-cli 3.1.3 → 4.0.0

package/dist/src/mcp-tools/transfer-tools.js

@@ -5,24 +5,61 @@
  * @module @claude-flow/cli/mcp-tools/transfer-tools
  * @version 3.0.0
  */
+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 };
+    }
+};
 /**
  * Helper to create MCP tool result
  */
-function createResult(data, isError = false) {
+function createResult(data, isError) {
+    if (isError === void 0) { isError = false; }
     return {
         content: [
             {
                 type: 'text',
-                text: typeof data === 'string' ? data : JSON.stringify(data, null, 2),
+                text: typeof data === 'string' ? data : JSON.stringify(data, null, 2)
             },
         ],
-        isError,
+        isError: isError
     };
 }
 /**
  * Transfer MCP tools for pattern export, import, anonymization, and sharing
  */
-export const transferTools = [
+export var transferTools = [
     // ═══════════════════════════════════════════════════════════════
     // ANONYMIZATION TOOLS
     // ═══════════════════════════════════════════════════════════════
@@ -36,21 +73,29 @@ export const transferTools = [
             properties: {
                 content: {
                     type: 'string',
-                    description: 'Content to scan for PII',
-                },
+                    description: 'Content to scan for PII'
+                }
             },
-            required: ['content'],
-        },
-        handler: async (input) => {
-            try {
-                const { detectPII } = await import('../transfer/anonymization/index.js');
-                const result = detectPII(input.content);
-                return createResult(result);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
+            required: ['content']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, Promise, function () {
+            var detectPII, result, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, import('../transfer/anonymization/index.js')];
+                    case 1:
+                        detectPII = (_a.sent()).detectPII;
+                        result = detectPII(input.content);
+                        return [2 /*return*/, createResult(result)];
+                    case 2:
+                        error_1 = _a.sent();
+                        return [2 /*return*/, createResult({ error: error_1.message }, true)];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     // ═══════════════════════════════════════════════════════════════
     // IPFS TOOLS
@@ -65,21 +110,31 @@ export const transferTools = [
             properties: {
                 name: {
                     type: 'string',
-                    description: 'IPNS name to resolve',
-                },
+                    description: 'IPNS name to resolve'
+                }
             },
-            required: ['name'],
-        },
-        handler: async (input) => {
-            try {
-                const { resolveIPNS } = await import('../transfer/ipfs/client.js');
-                const result = await resolveIPNS(input.name);
-                return createResult({ success: true, cid: result });
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
+            required: ['name']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, Promise, function () {
+            var resolveIPNS, result, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, import('../transfer/ipfs/client.js')];
+                    case 1:
+                        resolveIPNS = (_a.sent()).resolveIPNS;
+                        return [4 /*yield*/, resolveIPNS(input.name)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, createResult({ success: true, cid: result })];
+                    case 3:
+                        error_2 = _a.sent();
+                        return [2 /*return*/, createResult({ error: error_2.message }, true)];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     // ═══════════════════════════════════════════════════════════════
     // PATTERN STORE TOOLS
@@ -94,38 +149,48 @@ export const transferTools = [
             properties: {
                 query: {
                     type: 'string',
-                    description: 'Search query',
+                    description: 'Search query'
                 },
                 category: {
                     type: 'string',
-                    description: 'Filter by category',
+                    description: 'Filter by category'
                 },
                 minRating: {
                     type: 'number',
-                    description: 'Minimum rating',
+                    description: 'Minimum rating'
                 },
                 verified: {
                     type: 'boolean',
-                    description: 'Only show verified patterns',
+                    description: 'Only show verified patterns'
                 },
                 limit: {
                     type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const { PatternStore } = await import('../transfer/store/index.js');
-                const store = new PatternStore();
-                await store.initialize();
-                const results = store.search(input);
-                return createResult(results);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
+                    description: 'Maximum results'
+                }
             }
         },
+        handler: function (input) { return __awaiter(void 0, void 0, Promise, function () {
+            var PatternStore, store, results, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, import('../transfer/store/index.js')];
+                    case 1:
+                        PatternStore = (_a.sent()).PatternStore;
+                        store = new PatternStore();
+                        return [4 /*yield*/, store.initialize()];
+                    case 2:
+                        _a.sent();
+                        results = store.search(input);
+                        return [2 /*return*/, createResult(results)];
+                    case 3:
+                        error_3 = _a.sent();
+                        return [2 /*return*/, createResult({ error: error_3.message }, true)];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'transfer_store-info',
@@ -137,26 +202,36 @@ export const transferTools = [
             properties: {
                 id: {
                     type: 'string',
-                    description: 'Pattern ID',
-                },
+                    description: 'Pattern ID'
+                }
             },
-            required: ['id'],
+            required: ['id']
         },
-        handler: async (input) => {
-            try {
-                const { PatternStore } = await import('../transfer/store/index.js');
-                const store = new PatternStore();
-                await store.initialize();
-                const pattern = store.getPattern(input.id);
-                if (!pattern) {
-                    return createResult({ error: 'Pattern not found' }, true);
+        handler: function (input) { return __awaiter(void 0, void 0, Promise, function () {
+            var PatternStore, store, pattern, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, import('../transfer/store/index.js')];
+                    case 1:
+                        PatternStore = (_a.sent()).PatternStore;
+                        store = new PatternStore();
+                        return [4 /*yield*/, store.initialize()];
+                    case 2:
+                        _a.sent();
+                        pattern = store.getPattern(input.id);
+                        if (!pattern) {
+                            return [2 /*return*/, createResult({ error: 'Pattern not found' }, true)];
+                        }
+                        return [2 /*return*/, createResult(pattern)];
+                    case 3:
+                        error_4 = _a.sent();
+                        return [2 /*return*/, createResult({ error: error_4.message }, true)];
+                    case 4: return [2 /*return*/];
                 }
-                return createResult(pattern);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
+            });
+        }); }
     },
     {
         name: 'transfer_store-download',
@@ -168,27 +243,39 @@ export const transferTools = [
             properties: {
                 id: {
                     type: 'string',
-                    description: 'Pattern ID',
+                    description: 'Pattern ID'
                 },
                 verify: {
                     type: 'boolean',
-                    description: 'Verify pattern integrity',
-                },
+                    description: 'Verify pattern integrity'
+                }
             },
-            required: ['id'],
-        },
-        handler: async (input) => {
-            try {
-                const { PatternStore } = await import('../transfer/store/index.js');
-                const store = new PatternStore();
-                await store.initialize();
-                const result = await store.download(input.id, { verify: input.verify });
-                return createResult(result);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
+            required: ['id']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, Promise, function () {
+            var PatternStore, store, result, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 4, , 5]);
+                        return [4 /*yield*/, import('../transfer/store/index.js')];
+                    case 1:
+                        PatternStore = (_a.sent()).PatternStore;
+                        store = new PatternStore();
+                        return [4 /*yield*/, store.initialize()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, store.download(input.id, { verify: input.verify })];
+                    case 3:
+                        result = _a.sent();
+                        return [2 /*return*/, createResult(result)];
+                    case 4:
+                        error_5 = _a.sent();
+                        return [2 /*return*/, createResult({ error: error_5.message }, true)];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'transfer_store-featured',
@@ -200,23 +287,33 @@ export const transferTools = [
             properties: {
                 limit: {
                     type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const { PatternStore } = await import('../transfer/store/index.js');
-                const store = new PatternStore();
-                await store.initialize();
-                const featured = store.getFeatured();
-                const limit = input.limit || 10;
-                return createResult(featured.slice(0, limit));
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
+                    description: 'Maximum results'
+                }
             }
         },
+        handler: function (input) { return __awaiter(void 0, void 0, Promise, function () {
+            var PatternStore, store, featured, limit, error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, import('../transfer/store/index.js')];
+                    case 1:
+                        PatternStore = (_a.sent()).PatternStore;
+                        store = new PatternStore();
+                        return [4 /*yield*/, store.initialize()];
+                    case 2:
+                        _a.sent();
+                        featured = store.getFeatured();
+                        limit = input.limit || 10;
+                        return [2 /*return*/, createResult(featured.slice(0, limit))];
+                    case 3:
+                        error_6 = _a.sent();
+                        return [2 /*return*/, createResult({ error: error_6.message }, true)];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'transfer_store-trending',
@@ -228,23 +325,33 @@ export const transferTools = [
             properties: {
                 limit: {
                     type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const { PatternStore } = await import('../transfer/store/index.js');
-                const store = new PatternStore();
-                await store.initialize();
-                const trending = store.getTrending();
-                const limit = input.limit || 10;
-                return createResult(trending.slice(0, limit));
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
+                    description: 'Maximum results'
+                }
             }
         },
+        handler: function (input) { return __awaiter(void 0, void 0, Promise, function () {
+            var PatternStore, store, trending, limit, error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, import('../transfer/store/index.js')];
+                    case 1:
+                        PatternStore = (_a.sent()).PatternStore;
+                        store = new PatternStore();
+                        return [4 /*yield*/, store.initialize()];
+                    case 2:
+                        _a.sent();
+                        trending = store.getTrending();
+                        limit = input.limit || 10;
+                        return [2 /*return*/, createResult(trending.slice(0, limit))];
+                    case 3:
+                        error_7 = _a.sent();
+                        return [2 /*return*/, createResult({ error: error_7.message }, true)];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     // ═══════════════════════════════════════════════════════════════
     // PLUGIN STORE TOOLS
@@ -259,46 +366,56 @@ export const transferTools = [
             properties: {
                 query: {
                     type: 'string',
-                    description: 'Search query',
+                    description: 'Search query'
                 },
                 category: {
                     type: 'string',
-                    description: 'Filter by category',
+                    description: 'Filter by category'
                 },
                 type: {
                     type: 'string',
-                    description: 'Filter by plugin type',
+                    description: 'Filter by plugin type'
                 },
                 verified: {
                     type: 'boolean',
-                    description: 'Only show verified plugins',
+                    description: 'Only show verified plugins'
                 },
                 minRating: {
                     type: 'number',
-                    description: 'Minimum rating',
+                    description: 'Minimum rating'
                 },
                 limit: {
                     type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const { createPluginDiscoveryService, searchPlugins } = await import('../plugins/store/index.js');
-                const discovery = createPluginDiscoveryService();
-                const result = await discovery.discoverRegistry();
-                if (!result.success || !result.registry) {
-                    return createResult({ error: result.error || 'Failed to discover registry' }, true);
+                    description: 'Maximum results'
                 }
-                const opts = input;
-                const searchResult = searchPlugins(result.registry, opts);
-                return createResult(searchResult);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
             }
         },
+        handler: function (input) { return __awaiter(void 0, void 0, Promise, function () {
+            var _a, createPluginDiscoveryService, searchPlugins, discovery, result, opts, searchResult, error_8;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, import('../plugins/store/index.js')];
+                    case 1:
+                        _a = _b.sent(), createPluginDiscoveryService = _a.createPluginDiscoveryService, searchPlugins = _a.searchPlugins;
+                        discovery = createPluginDiscoveryService();
+                        return [4 /*yield*/, discovery.discoverRegistry()];
+                    case 2:
+                        result = _b.sent();
+                        if (!result.success || !result.registry) {
+                            return [2 /*return*/, createResult({ error: result.error || 'Failed to discover registry' }, true)];
+                        }
+                        opts = input;
+                        searchResult = searchPlugins(result.registry, opts);
+                        return [2 /*return*/, createResult(searchResult)];
+                    case 3:
+                        error_8 = _b.sent();
+                        return [2 /*return*/, createResult({ error: error_8.message }, true)];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'transfer_plugin-info',
@@ -310,30 +427,40 @@ export const transferTools = [
             properties: {
                 name: {
                     type: 'string',
-                    description: 'Plugin name or ID',
-                },
+                    description: 'Plugin name or ID'
+                }
             },
-            required: ['name'],
+            required: ['name']
         },
-        handler: async (input) => {
-            try {
-                const { createPluginDiscoveryService } = await import('../plugins/store/index.js');
-                const discovery = createPluginDiscoveryService();
-                const result = await discovery.discoverRegistry();
-                if (!result.success || !result.registry) {
-                    return createResult({ error: result.error || 'Failed to discover registry' }, true);
-                }
-                const name = input.name;
-                const plugin = result.registry.plugins.find((p) => p.id === name || p.name === name);
-                if (!plugin) {
-                    return createResult({ error: 'Plugin not found' }, true);
+        handler: function (input) { return __awaiter(void 0, void 0, Promise, function () {
+            var createPluginDiscoveryService, discovery, result, name_1, plugin, error_9;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, import('../plugins/store/index.js')];
+                    case 1:
+                        createPluginDiscoveryService = (_a.sent()).createPluginDiscoveryService;
+                        discovery = createPluginDiscoveryService();
+                        return [4 /*yield*/, discovery.discoverRegistry()];
+                    case 2:
+                        result = _a.sent();
+                        if (!result.success || !result.registry) {
+                            return [2 /*return*/, createResult({ error: result.error || 'Failed to discover registry' }, true)];
+                        }
+                        name_1 = input.name;
+                        plugin = result.registry.plugins.find(function (p) { return p.id === name_1 || p.name === name_1; });
+                        if (!plugin) {
+                            return [2 /*return*/, createResult({ error: 'Plugin not found' }, true)];
+                        }
+                        return [2 /*return*/, createResult(plugin)];
+                    case 3:
+                        error_9 = _a.sent();
+                        return [2 /*return*/, createResult({ error: error_9.message }, true)];
+                    case 4: return [2 /*return*/];
                 }
-                return createResult(plugin);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
+            });
+        }); }
     },
     {
         name: 'transfer_plugin-featured',
@@ -345,26 +472,36 @@ export const transferTools = [
             properties: {
                 limit: {
                     type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const { createPluginDiscoveryService, getFeaturedPlugins } = await import('../plugins/store/index.js');
-                const discovery = createPluginDiscoveryService();
-                const result = await discovery.discoverRegistry();
-                if (!result.success || !result.registry) {
-                    return createResult({ error: result.error || 'Failed to discover registry' }, true);
+                    description: 'Maximum results'
                 }
-                const featured = getFeaturedPlugins(result.registry);
-                const limit = input.limit || 10;
-                return createResult(featured.slice(0, limit));
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
             }
         },
+        handler: function (input) { return __awaiter(void 0, void 0, Promise, function () {
+            var _a, createPluginDiscoveryService, getFeaturedPlugins, discovery, result, featured, limit, error_10;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, import('../plugins/store/index.js')];
+                    case 1:
+                        _a = _b.sent(), createPluginDiscoveryService = _a.createPluginDiscoveryService, getFeaturedPlugins = _a.getFeaturedPlugins;
+                        discovery = createPluginDiscoveryService();
+                        return [4 /*yield*/, discovery.discoverRegistry()];
+                    case 2:
+                        result = _b.sent();
+                        if (!result.success || !result.registry) {
+                            return [2 /*return*/, createResult({ error: result.error || 'Failed to discover registry' }, true)];
+                        }
+                        featured = getFeaturedPlugins(result.registry);
+                        limit = input.limit || 10;
+                        return [2 /*return*/, createResult(featured.slice(0, limit))];
+                    case 3:
+                        error_10 = _b.sent();
+                        return [2 /*return*/, createResult({ error: error_10.message }, true)];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'transfer_plugin-official',
@@ -373,23 +510,33 @@ export const transferTools = [
         version: '1.0.0',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {}
         },
-        handler: async () => {
-            try {
-                const { createPluginDiscoveryService, getOfficialPlugins } = await import('../plugins/store/index.js');
-                const discovery = createPluginDiscoveryService();
-                const result = await discovery.discoverRegistry();
-                if (!result.success || !result.registry) {
-                    return createResult({ error: result.error || 'Failed to discover registry' }, true);
+        handler: function () { return __awaiter(void 0, void 0, Promise, function () {
+            var _a, createPluginDiscoveryService, getOfficialPlugins, discovery, result, official, error_11;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, import('../plugins/store/index.js')];
+                    case 1:
+                        _a = _b.sent(), createPluginDiscoveryService = _a.createPluginDiscoveryService, getOfficialPlugins = _a.getOfficialPlugins;
+                        discovery = createPluginDiscoveryService();
+                        return [4 /*yield*/, discovery.discoverRegistry()];
+                    case 2:
+                        result = _b.sent();
+                        if (!result.success || !result.registry) {
+                            return [2 /*return*/, createResult({ error: result.error || 'Failed to discover registry' }, true)];
+                        }
+                        official = getOfficialPlugins(result.registry);
+                        return [2 /*return*/, createResult(official)];
+                    case 3:
+                        error_11 = _b.sent();
+                        return [2 /*return*/, createResult({ error: error_11.message }, true)];
+                    case 4: return [2 /*return*/];
                 }
-                const official = getOfficialPlugins(result.registry);
-                return createResult(official);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
+            });
+        }); }
     },
 ];
 export default transferTools;