kynjal-cli 3.1.4 → 4.0.0

package/dist/src/commands/transfer-store.js

@@ -2,10 +2,46 @@
  * V3 CLI Transfer Store Commands
  * Pattern marketplace - list, search, download, publish
  */
+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 { output } from '../output.js';
 import { createDiscoveryService, createDownloader, createPublisher, searchPatterns, } from '../transfer/index.js';
 // Store list subcommand
-export const storeListCommand = {
+export var storeListCommand = {
     name: 'list',
     aliases: ['ls'],
     description: 'List patterns from decentralized registry',
@@ -15,94 +51,103 @@ export const storeListCommand = {
         { name: 'featured', short: 'f', type: 'boolean', description: 'Show featured patterns' },
         { name: 'trending', short: 't', type: 'boolean', description: 'Show trending patterns' },
         { name: 'newest', short: 'n', type: 'boolean', description: 'Show newest patterns' },
-        { name: 'limit', short: 'l', type: 'number', description: 'Maximum results', default: 20 },
+        { name: 'limit', short: 'l', type: 'number', description: 'Maximum results', "default": 20 },
     ],
     examples: [
         { command: 'claude-flow hooks transfer store list', description: 'List all patterns' },
         { command: 'claude-flow hooks transfer store list --category routing', description: 'List routing patterns' },
         { command: 'claude-flow hooks transfer store list --featured', description: 'List featured patterns' },
     ],
-    action: async (ctx) => {
-        const registryName = ctx.flags.registry;
-        const category = ctx.flags.category;
-        const featured = ctx.flags.featured;
-        const trending = ctx.flags.trending;
-        const newest = ctx.flags.newest;
-        const limit = ctx.flags.limit || 20;
-        const spinner = output.createSpinner({ text: 'Discovering registry...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const discovery = createDiscoveryService();
-            const result = await discovery.discoverRegistry(registryName);
-            if (!result.success || !result.registry) {
-                spinner.fail('Failed to discover registry');
-                output.printError(result.error || 'Unknown error');
-                return { success: false, exitCode: 1 };
-            }
-            spinner.succeed(`Connected to ${result.source}`);
-            // Get patterns based on flags
-            let patterns = result.registry.patterns;
-            let title = 'Available Patterns';
-            if (featured) {
-                patterns = result.registry.featured
-                    .map(id => patterns.find(p => p.id === id))
-                    .filter((p) => p !== undefined);
-                title = 'Featured Patterns';
-            }
-            else if (trending) {
-                patterns = result.registry.trending
-                    .map(id => patterns.find(p => p.id === id))
-                    .filter((p) => p !== undefined);
-                title = 'Trending Patterns';
-            }
-            else if (newest) {
-                patterns = result.registry.newest
-                    .map(id => patterns.find(p => p.id === id))
-                    .filter((p) => p !== undefined);
-                title = 'Newest Patterns';
-            }
-            if (category) {
-                patterns = patterns.filter(p => p.categories.includes(category));
-                title = `Patterns in "${category}"`;
-            }
-            patterns = patterns.slice(0, limit);
-            output.writeln();
-            output.writeln(output.bold(title));
-            output.writeln(output.dim('─'.repeat(70)));
-            if (patterns.length === 0) {
-                output.writeln(output.dim('No patterns found'));
-            }
-            else {
-                output.printTable({
-                    columns: [
-                        { key: 'name', header: 'Name', width: 25 },
-                        { key: 'version', header: 'Version', width: 10 },
-                        { key: 'downloads', header: 'Downloads', width: 12 },
-                        { key: 'rating', header: 'Rating', width: 10 },
-                        { key: 'verified', header: 'Status', width: 12 },
-                    ],
-                    data: patterns.map(p => ({
-                        name: p.displayName,
-                        version: p.version,
-                        downloads: p.downloads.toLocaleString(),
-                        rating: `${p.rating.toFixed(1)}/5`,
-                        verified: p.verified ? output.success('Verified') : output.dim('Community'),
-                    })),
-                });
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var registryName, category, featured, trending, newest, limit, spinner, discovery, result, patterns_1, title, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    registryName = ctx.flags.registry;
+                    category = ctx.flags.category;
+                    featured = ctx.flags.featured;
+                    trending = ctx.flags.trending;
+                    newest = ctx.flags.newest;
+                    limit = ctx.flags.limit || 20;
+                    spinner = output.createSpinner({ text: 'Discovering registry...', spinner: 'dots' });
+                    spinner.start();
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    discovery = createDiscoveryService();
+                    return [4 /*yield*/, discovery.discoverRegistry(registryName)];
+                case 2:
+                    result = _a.sent();
+                    if (!result.success || !result.registry) {
+                        spinner.fail('Failed to discover registry');
+                        output.printError(result.error || 'Unknown error');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner.succeed("Connected to " + result.source);
+                    patterns_1 = result.registry.patterns;
+                    title = 'Available Patterns';
+                    if (featured) {
+                        patterns_1 = result.registry.featured
+                            .map(function (id) { return patterns_1.find(function (p) { return p.id === id; }); })
+                            .filter(function (p) { return p !== undefined; });
+                        title = 'Featured Patterns';
+                    }
+                    else if (trending) {
+                        patterns_1 = result.registry.trending
+                            .map(function (id) { return patterns_1.find(function (p) { return p.id === id; }); })
+                            .filter(function (p) { return p !== undefined; });
+                        title = 'Trending Patterns';
+                    }
+                    else if (newest) {
+                        patterns_1 = result.registry.newest
+                            .map(function (id) { return patterns_1.find(function (p) { return p.id === id; }); })
+                            .filter(function (p) { return p !== undefined; });
+                        title = 'Newest Patterns';
+                    }
+                    if (category) {
+                        patterns_1 = patterns_1.filter(function (p) { return p.categories.includes(category); });
+                        title = "Patterns in \"" + category + "\"";
+                    }
+                    patterns_1 = patterns_1.slice(0, limit);
+                    output.writeln();
+                    output.writeln(output.bold(title));
+                    output.writeln(output.dim('─'.repeat(70)));
+                    if (patterns_1.length === 0) {
+                        output.writeln(output.dim('No patterns found'));
+                    }
+                    else {
+                        output.printTable({
+                            columns: [
+                                { key: 'name', header: 'Name', width: 25 },
+                                { key: 'version', header: 'Version', width: 10 },
+                                { key: 'downloads', header: 'Downloads', width: 12 },
+                                { key: 'rating', header: 'Rating', width: 10 },
+                                { key: 'verified', header: 'Status', width: 12 },
+                            ],
+                            data: patterns_1.map(function (p) { return ({
+                                name: p.displayName,
+                                version: p.version,
+                                downloads: p.downloads.toLocaleString(),
+                                rating: p.rating.toFixed(1) + "/5",
+                                verified: p.verified ? output.success('Verified') : output.dim('Community')
+                            }); })
+                        });
+                    }
+                    output.writeln();
+                    output.writeln(output.dim("Registry: " + result.source + " | Total: " + result.registry.totalPatterns + " patterns"));
+                    return [2 /*return*/, { success: true }];
+                case 3:
+                    error_1 = _a.sent();
+                    spinner.fail('Error listing patterns');
+                    output.printError(String(error_1));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            output.writeln();
-            output.writeln(output.dim(`Registry: ${result.source} | Total: ${result.registry.totalPatterns} patterns`));
-            return { success: true };
-        }
-        catch (error) {
-            spinner.fail('Error listing patterns');
-            output.printError(String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 // Store search subcommand
-export const storeSearchCommand = {
+export var storeSearchCommand = {
     name: 'search',
     description: 'Search patterns in the decentralized registry',
     options: [
@@ -113,135 +158,157 @@ export const storeSearchCommand = {
         { name: 'tags', short: 't', type: 'string', description: 'Filter by tags (comma-separated)' },
         { name: 'min-rating', type: 'number', description: 'Minimum rating (0-5)' },
         { name: 'verified', short: 'v', type: 'boolean', description: 'Only verified patterns' },
-        { name: 'limit', type: 'number', description: 'Maximum results', default: 20 },
+        { name: 'limit', type: 'number', description: 'Maximum results', "default": 20 },
     ],
     examples: [
         { command: 'claude-flow hooks transfer store search -q "routing"', description: 'Search for routing patterns' },
         { command: 'claude-flow hooks transfer store search -q "react" --language typescript', description: 'Search with filters' },
     ],
-    action: async (ctx) => {
-        const query = (ctx.args[0] || ctx.flags.query);
-        if (!query) {
-            output.printError('Search query is required. Use --query or -q flag.');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Searching patterns...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const discovery = createDiscoveryService();
-            const result = await discovery.discoverRegistry();
-            if (!result.success || !result.registry) {
-                spinner.fail('Failed to discover registry');
-                return { success: false, exitCode: 1 };
-            }
-            const searchOptions = {
-                query,
-                category: ctx.flags.category,
-                language: ctx.flags.language,
-                framework: ctx.flags.framework,
-                tags: ctx.flags.tags ? ctx.flags.tags.split(',') : undefined,
-                minRating: ctx.flags.minRating,
-                verified: ctx.flags.verified,
-                limit: ctx.flags.limit || 20,
-            };
-            const searchResult = searchPatterns(result.registry, searchOptions);
-            spinner.succeed(`Found ${searchResult.total} patterns`);
-            output.writeln();
-            output.writeln(output.bold(`Search Results for "${query}"`));
-            output.writeln(output.dim('─'.repeat(70)));
-            if (searchResult.patterns.length === 0) {
-                output.writeln(output.dim('No patterns match your search'));
-            }
-            else {
-                for (const pattern of searchResult.patterns) {
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var query, spinner, discovery, result, searchOptions, searchResult, _i, _a, pattern, error_2;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    query = (ctx.args[0] || ctx.flags.query);
+                    if (!query) {
+                        output.printError('Search query is required. Use --query or -q flag.');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner = output.createSpinner({ text: 'Searching patterns...', spinner: 'dots' });
+                    spinner.start();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    discovery = createDiscoveryService();
+                    return [4 /*yield*/, discovery.discoverRegistry()];
+                case 2:
+                    result = _b.sent();
+                    if (!result.success || !result.registry) {
+                        spinner.fail('Failed to discover registry');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    searchOptions = {
+                        query: query,
+                        category: ctx.flags.category,
+                        language: ctx.flags.language,
+                        framework: ctx.flags.framework,
+                        tags: ctx.flags.tags ? ctx.flags.tags.split(',') : undefined,
+                        minRating: ctx.flags.minRating,
+                        verified: ctx.flags.verified,
+                        limit: ctx.flags.limit || 20
+                    };
+                    searchResult = searchPatterns(result.registry, searchOptions);
+                    spinner.succeed("Found " + searchResult.total + " patterns");
                     output.writeln();
-                    output.writeln(`  ${output.bold(pattern.displayName)} ${output.dim(`v${pattern.version}`)}`);
-                    output.writeln(`  ${output.dim(pattern.description.slice(0, 70))}...`);
-                    output.writeln(`  ${output.dim('Tags:')} ${pattern.tags.slice(0, 5).join(', ')}`);
-                    output.writeln(`  ${output.dim('Rating:')} ${pattern.rating.toFixed(1)}/5 | ${output.dim('Downloads:')} ${pattern.downloads}`);
-                }
+                    output.writeln(output.bold("Search Results for \"" + query + "\""));
+                    output.writeln(output.dim('─'.repeat(70)));
+                    if (searchResult.patterns.length === 0) {
+                        output.writeln(output.dim('No patterns match your search'));
+                    }
+                    else {
+                        for (_i = 0, _a = searchResult.patterns; _i < _a.length; _i++) {
+                            pattern = _a[_i];
+                            output.writeln();
+                            output.writeln("  " + output.bold(pattern.displayName) + " " + output.dim("v" + pattern.version));
+                            output.writeln("  " + output.dim(pattern.description.slice(0, 70)) + "...");
+                            output.writeln("  " + output.dim('Tags:') + " " + pattern.tags.slice(0, 5).join(', '));
+                            output.writeln("  " + output.dim('Rating:') + " " + pattern.rating.toFixed(1) + "/5 | " + output.dim('Downloads:') + " " + pattern.downloads);
+                        }
+                    }
+                    output.writeln();
+                    output.writeln(output.dim("Showing " + searchResult.patterns.length + " of " + searchResult.total + " results"));
+                    return [2 /*return*/, { success: true, data: searchResult }];
+                case 3:
+                    error_2 = _b.sent();
+                    spinner.fail('Search failed');
+                    output.printError(String(error_2));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            output.writeln();
-            output.writeln(output.dim(`Showing ${searchResult.patterns.length} of ${searchResult.total} results`));
-            return { success: true, data: searchResult };
-        }
-        catch (error) {
-            spinner.fail('Search failed');
-            output.printError(String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 // Store download subcommand
-export const storeDownloadCommand = {
+export var storeDownloadCommand = {
     name: 'download',
     aliases: ['get', 'install'],
     description: 'Download a pattern from the registry',
     options: [
         { name: 'name', short: 'n', type: 'string', description: 'Pattern name or ID', required: true },
         { name: 'output', short: 'o', type: 'string', description: 'Output path' },
-        { name: 'verify', short: 'v', type: 'boolean', description: 'Verify checksum', default: true },
+        { name: 'verify', short: 'v', type: 'boolean', description: 'Verify checksum', "default": true },
         { name: 'import', short: 'i', type: 'boolean', description: 'Import after download' },
     ],
     examples: [
         { command: 'claude-flow hooks transfer store download -n seraphine-genesis', description: 'Download pattern' },
         { command: 'claude-flow hooks transfer store download -n seraphine-genesis --import', description: 'Download and import' },
     ],
-    action: async (ctx) => {
-        const patternName = (ctx.args[0] || ctx.flags.name);
-        if (!patternName) {
-            output.printError('Pattern name is required. Use --name or -n flag.');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Finding pattern...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const discovery = createDiscoveryService();
-            const result = await discovery.discoverRegistry();
-            if (!result.success || !result.registry) {
-                spinner.fail('Failed to discover registry');
-                return { success: false, exitCode: 1 };
-            }
-            // Find pattern by name or ID
-            const pattern = result.registry.patterns.find(p => p.name === patternName || p.id === patternName || p.displayName === patternName);
-            if (!pattern) {
-                spinner.fail(`Pattern not found: ${patternName}`);
-                return { success: false, exitCode: 1 };
-            }
-            spinner.setText(`Downloading ${pattern.displayName}...`);
-            const downloader = createDownloader();
-            const downloadResult = await downloader.downloadPattern(pattern, {
-                output: ctx.flags.output,
-                verify: ctx.flags.verify,
-                import: ctx.flags.import,
-            }, (progress) => {
-                spinner.setText(`Downloading... ${progress.percentage}%`);
-            });
-            if (!downloadResult.success) {
-                spinner.fail('Download failed');
-                return { success: false, exitCode: 1 };
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var patternName, spinner, discovery, result, pattern, downloader, downloadResult, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    patternName = (ctx.args[0] || ctx.flags.name);
+                    if (!patternName) {
+                        output.printError('Pattern name is required. Use --name or -n flag.');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner = output.createSpinner({ text: 'Finding pattern...', spinner: 'dots' });
+                    spinner.start();
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    discovery = createDiscoveryService();
+                    return [4 /*yield*/, discovery.discoverRegistry()];
+                case 2:
+                    result = _a.sent();
+                    if (!result.success || !result.registry) {
+                        spinner.fail('Failed to discover registry');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    pattern = result.registry.patterns.find(function (p) { return p.name === patternName || p.id === patternName || p.displayName === patternName; });
+                    if (!pattern) {
+                        spinner.fail("Pattern not found: " + patternName);
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner.setText("Downloading " + pattern.displayName + "...");
+                    downloader = createDownloader();
+                    return [4 /*yield*/, downloader.downloadPattern(pattern, {
+                            output: ctx.flags.output,
+                            verify: ctx.flags.verify,
+                            "import": ctx.flags["import"]
+                        }, function (progress) {
+                            spinner.setText("Downloading... " + progress.percentage + "%");
+                        })];
+                case 3:
+                    downloadResult = _a.sent();
+                    if (!downloadResult.success) {
+                        spinner.fail('Download failed');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner.succeed("Downloaded " + pattern.displayName);
+                    output.writeln();
+                    output.printBox([
+                        "Pattern: " + pattern.displayName,
+                        "Version: " + pattern.version,
+                        "Size: " + downloadResult.size.toLocaleString() + " bytes",
+                        "Verified: " + (downloadResult.verified ? 'Yes' : 'No'),
+                        downloadResult.outputPath ? "Path: " + downloadResult.outputPath : '',
+                        downloadResult.imported ? 'Status: Imported' : '',
+                    ].filter(Boolean).join('\n'), 'Download Complete');
+                    return [2 /*return*/, { success: true, data: downloadResult }];
+                case 4:
+                    error_3 = _a.sent();
+                    spinner.fail('Download failed');
+                    output.printError(String(error_3));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 5: return [2 /*return*/];
             }
-            spinner.succeed(`Downloaded ${pattern.displayName}`);
-            output.writeln();
-            output.printBox([
-                `Pattern: ${pattern.displayName}`,
-                `Version: ${pattern.version}`,
-                `Size: ${downloadResult.size.toLocaleString()} bytes`,
-                `Verified: ${downloadResult.verified ? 'Yes' : 'No'}`,
-                downloadResult.outputPath ? `Path: ${downloadResult.outputPath}` : '',
-                downloadResult.imported ? 'Status: Imported' : '',
-            ].filter(Boolean).join('\n'), 'Download Complete');
-            return { success: true, data: downloadResult };
-        }
-        catch (error) {
-            spinner.fail('Download failed');
-            output.printError(String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 // Store publish subcommand
-export const storePublishCommand = {
+export var storePublishCommand = {
     name: 'publish',
     aliases: ['contribute'],
     description: 'Publish a pattern to the decentralized registry',
@@ -251,72 +318,83 @@ export const storePublishCommand = {
         { name: 'description', short: 'd', type: 'string', description: 'Pattern description', required: true },
         { name: 'categories', short: 'c', type: 'string', description: 'Categories (comma-separated)', required: true },
         { name: 'tags', short: 't', type: 'string', description: 'Tags (comma-separated)', required: true },
-        { name: 'license', short: 'l', type: 'string', description: 'SPDX license', default: 'MIT' },
-        { name: 'anonymize', short: 'a', type: 'string', description: 'Anonymization level', default: 'strict' },
+        { name: 'license', short: 'l', type: 'string', description: 'SPDX license', "default": 'MIT' },
+        { name: 'anonymize', short: 'a', type: 'string', description: 'Anonymization level', "default": 'strict' },
         { name: 'language', type: 'string', description: 'Primary language' },
         { name: 'framework', type: 'string', description: 'Primary framework' },
     ],
     examples: [
         { command: 'claude-flow hooks transfer store publish -i patterns.cfp -n my-patterns -d "My patterns" -c routing -t custom', description: 'Publish pattern' },
     ],
-    action: async (ctx) => {
-        const inputPath = ctx.flags.input;
-        const name = ctx.flags.name;
-        const description = ctx.flags.description;
-        if (!inputPath || !name || !description) {
-            output.printError('Input path, name, and description are required.');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Preparing pattern...', spinner: 'dots' });
-        spinner.start();
-        try {
-            // Read and parse CFP file
-            const fs = await import('fs');
-            if (!fs.existsSync(inputPath)) {
-                spinner.fail(`File not found: ${inputPath}`);
-                return { success: false, exitCode: 1 };
-            }
-            const content = fs.readFileSync(inputPath, 'utf-8');
-            const cfp = JSON.parse(content);
-            spinner.setText('Publishing to IPFS...');
-            const publisher = createPublisher();
-            const result = await publisher.publishPattern(cfp, {
-                name,
-                displayName: name.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
-                description,
-                categories: ctx.flags.categories.split(',').map(s => s.trim()),
-                tags: ctx.flags.tags.split(',').map(s => s.trim()),
-                license: ctx.flags.license || 'MIT',
-                anonymize: ctx.flags.anonymize || 'strict',
-                language: ctx.flags.language,
-                framework: ctx.flags.framework,
-            });
-            if (!result.success) {
-                spinner.fail('Publish failed');
-                output.printError(result.message);
-                return { success: false, exitCode: 1 };
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var inputPath, name, description, spinner, fs, content, cfp, publisher, result, error_4;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    inputPath = ctx.flags.input;
+                    name = ctx.flags.name;
+                    description = ctx.flags.description;
+                    if (!inputPath || !name || !description) {
+                        output.printError('Input path, name, and description are required.');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner = output.createSpinner({ text: 'Preparing pattern...', spinner: 'dots' });
+                    spinner.start();
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, import('fs')];
+                case 2:
+                    fs = _a.sent();
+                    if (!fs.existsSync(inputPath)) {
+                        spinner.fail("File not found: " + inputPath);
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    content = fs.readFileSync(inputPath, 'utf-8');
+                    cfp = JSON.parse(content);
+                    spinner.setText('Publishing to IPFS...');
+                    publisher = createPublisher();
+                    return [4 /*yield*/, publisher.publishPattern(cfp, {
+                            name: name,
+                            displayName: name.replace(/-/g, ' ').replace(/\b\w/g, function (c) { return c.toUpperCase(); }),
+                            description: description,
+                            categories: ctx.flags.categories.split(',').map(function (s) { return s.trim(); }),
+                            tags: ctx.flags.tags.split(',').map(function (s) { return s.trim(); }),
+                            license: ctx.flags.license || 'MIT',
+                            anonymize: ctx.flags.anonymize || 'strict',
+                            language: ctx.flags.language,
+                            framework: ctx.flags.framework
+                        })];
+                case 3:
+                    result = _a.sent();
+                    if (!result.success) {
+                        spinner.fail('Publish failed');
+                        output.printError(result.message);
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner.succeed('Pattern published!');
+                    output.writeln();
+                    output.printBox([
+                        "Pattern ID: " + result.patternId,
+                        "CID: " + result.cid,
+                        "Gateway URL: " + result.gatewayUrl,
+                        "",
+                        "Your pattern has been uploaded to IPFS.",
+                        "Submit a contribution request to add it to the official registry.",
+                    ].join('\n'), 'Publish Complete');
+                    return [2 /*return*/, { success: true, data: result }];
+                case 4:
+                    error_4 = _a.sent();
+                    spinner.fail('Publish failed');
+                    output.printError(String(error_4));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 5: return [2 /*return*/];
             }
-            spinner.succeed('Pattern published!');
-            output.writeln();
-            output.printBox([
-                `Pattern ID: ${result.patternId}`,
-                `CID: ${result.cid}`,
-                `Gateway URL: ${result.gatewayUrl}`,
-                ``,
-                `Your pattern has been uploaded to IPFS.`,
-                `Submit a contribution request to add it to the official registry.`,
-            ].join('\n'), 'Publish Complete');
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Publish failed');
-            output.printError(String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 // Store info subcommand
-export const storeInfoCommand = {
+export var storeInfoCommand = {
     name: 'info',
     description: 'Show detailed information about a pattern',
     options: [
@@ -325,69 +403,79 @@ export const storeInfoCommand = {
     examples: [
         { command: 'claude-flow hooks transfer store info -n seraphine-genesis', description: 'Show pattern info' },
     ],
-    action: async (ctx) => {
-        const patternName = (ctx.args[0] || ctx.flags.name);
-        if (!patternName) {
-            output.printError('Pattern name is required. Use --name or -n flag.');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Fetching pattern info...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const discovery = createDiscoveryService();
-            const result = await discovery.discoverRegistry();
-            if (!result.success || !result.registry) {
-                spinner.fail('Failed to discover registry');
-                return { success: false, exitCode: 1 };
-            }
-            const pattern = result.registry.patterns.find(p => p.name === patternName || p.id === patternName || p.displayName === patternName);
-            if (!pattern) {
-                spinner.fail(`Pattern not found: ${patternName}`);
-                return { success: false, exitCode: 1 };
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var patternName, spinner, discovery, result, pattern, error_5;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    patternName = (ctx.args[0] || ctx.flags.name);
+                    if (!patternName) {
+                        output.printError('Pattern name is required. Use --name or -n flag.');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner = output.createSpinner({ text: 'Fetching pattern info...', spinner: 'dots' });
+                    spinner.start();
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    discovery = createDiscoveryService();
+                    return [4 /*yield*/, discovery.discoverRegistry()];
+                case 2:
+                    result = _a.sent();
+                    if (!result.success || !result.registry) {
+                        spinner.fail('Failed to discover registry');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    pattern = result.registry.patterns.find(function (p) { return p.name === patternName || p.id === patternName || p.displayName === patternName; });
+                    if (!pattern) {
+                        spinner.fail("Pattern not found: " + patternName);
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner.succeed('Pattern found');
+                    output.writeln();
+                    output.printBox([
+                        "Name: " + pattern.displayName,
+                        "ID: " + pattern.id,
+                        "Version: " + pattern.version,
+                        "",
+                        "Description:",
+                        "  " + pattern.description,
+                        "",
+                        "Author: " + (pattern.author.displayName || pattern.author.id),
+                        "License: " + pattern.license,
+                        "",
+                        "Categories: " + pattern.categories.join(', '),
+                        "Tags: " + pattern.tags.join(', '),
+                        "",
+                        "Stats:",
+                        "  Downloads: " + pattern.downloads.toLocaleString(),
+                        "  Rating: " + pattern.rating.toFixed(1) + "/5 (" + pattern.ratingCount + " reviews)",
+                        "",
+                        "IPFS:",
+                        "  CID: " + pattern.cid,
+                        "  Size: " + pattern.size.toLocaleString() + " bytes",
+                        "  Checksum: " + pattern.checksum.slice(0, 16) + "...",
+                        "",
+                        "Trust: " + pattern.trustLevel,
+                        "Verified: " + (pattern.verified ? 'Yes' : 'No'),
+                        "Min Version: " + pattern.minClaudeFlowVersion,
+                        "",
+                        "Created: " + pattern.createdAt,
+                        "Updated: " + pattern.lastUpdated,
+                    ].join('\n'), 'Pattern Details');
+                    return [2 /*return*/, { success: true, data: pattern }];
+                case 3:
+                    error_5 = _a.sent();
+                    spinner.fail('Error fetching pattern info');
+                    output.printError(String(error_5));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            spinner.succeed('Pattern found');
-            output.writeln();
-            output.printBox([
-                `Name: ${pattern.displayName}`,
-                `ID: ${pattern.id}`,
-                `Version: ${pattern.version}`,
-                ``,
-                `Description:`,
-                `  ${pattern.description}`,
-                ``,
-                `Author: ${pattern.author.displayName || pattern.author.id}`,
-                `License: ${pattern.license}`,
-                ``,
-                `Categories: ${pattern.categories.join(', ')}`,
-                `Tags: ${pattern.tags.join(', ')}`,
-                ``,
-                `Stats:`,
-                `  Downloads: ${pattern.downloads.toLocaleString()}`,
-                `  Rating: ${pattern.rating.toFixed(1)}/5 (${pattern.ratingCount} reviews)`,
-                ``,
-                `IPFS:`,
-                `  CID: ${pattern.cid}`,
-                `  Size: ${pattern.size.toLocaleString()} bytes`,
-                `  Checksum: ${pattern.checksum.slice(0, 16)}...`,
-                ``,
-                `Trust: ${pattern.trustLevel}`,
-                `Verified: ${pattern.verified ? 'Yes' : 'No'}`,
-                `Min Version: ${pattern.minClaudeFlowVersion}`,
-                ``,
-                `Created: ${pattern.createdAt}`,
-                `Updated: ${pattern.lastUpdated}`,
-            ].join('\n'), 'Pattern Details');
-            return { success: true, data: pattern };
-        }
-        catch (error) {
-            spinner.fail('Error fetching pattern info');
-            output.printError(String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 // Main store command
-export const storeCommand = {
+export var storeCommand = {
     name: 'store',
     description: 'Pattern marketplace - list, search, download, publish',
     subcommands: [
@@ -403,26 +491,28 @@ export const storeCommand = {
         { command: 'claude-flow hooks transfer store download -n seraphine-genesis', description: 'Download pattern' },
         { command: 'claude-flow hooks transfer store publish -i patterns.cfp ...', description: 'Publish pattern' },
     ],
-    action: async () => {
-        output.writeln();
-        output.writeln(output.bold('KynjalFlow Pattern Store'));
-        output.writeln(output.dim('Decentralized pattern marketplace via IPFS'));
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            'list      - List patterns from registry',
-            'search    - Search patterns',
-            'download  - Download a pattern',
-            'publish   - Publish a pattern',
-            'info      - Show pattern details',
-        ]);
-        output.writeln();
-        output.writeln('Example:');
-        output.writeln(output.dim('  claude-flow hooks transfer store list --featured'));
-        output.writeln(output.dim('  claude-flow hooks transfer store search -q "routing"'));
-        output.writeln(output.dim('  claude-flow hooks transfer store download -n seraphine-genesis'));
-        return { success: true };
-    },
+    action: function () { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            output.writeln();
+            output.writeln(output.bold('RuFlo Pattern Store'));
+            output.writeln(output.dim('Decentralized pattern marketplace via IPFS'));
+            output.writeln();
+            output.writeln('Subcommands:');
+            output.printList([
+                'list      - List patterns from registry',
+                'search    - Search patterns',
+                'download  - Download a pattern',
+                'publish   - Publish a pattern',
+                'info      - Show pattern details',
+            ]);
+            output.writeln();
+            output.writeln('Example:');
+            output.writeln(output.dim('  claude-flow hooks transfer store list --featured'));
+            output.writeln(output.dim('  claude-flow hooks transfer store search -q "routing"'));
+            output.writeln(output.dim('  claude-flow hooks transfer store download -n seraphine-genesis'));
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 export default storeCommand;
 //# sourceMappingURL=transfer-store.js.map