kynjal-cli 4.0.0 → 4.0.1

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

@@ -2,46 +2,10 @@
  * 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 var storeListCommand = {
+export const storeListCommand = {
     name: 'list',
     aliases: ['ls'],
     description: 'List patterns from decentralized registry',
@@ -51,103 +15,94 @@ export var 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: 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*/];
+    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'),
+                    })),
+                });
+            }
+            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 var storeSearchCommand = {
+export const storeSearchCommand = {
     name: 'search',
     description: 'Search patterns in the decentralized registry',
     options: [
@@ -158,157 +113,135 @@ export var 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: 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("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);
-                        }
-                    }
+    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) {
                     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.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 { success: true, data: searchResult };
+        }
+        catch (error) {
+            spinner.fail('Search failed');
+            output.printError(String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Store download subcommand
-export var storeDownloadCommand = {
+export const 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: 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*/];
+    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 };
+            }
+            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 var storePublishCommand = {
+export const storePublishCommand = {
     name: 'publish',
     aliases: ['contribute'],
     description: 'Publish a pattern to the decentralized registry',
@@ -318,83 +251,72 @@ export var 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: 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*/];
+    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 };
             }
-        });
-    }); }
+            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 var storeInfoCommand = {
+export const storeInfoCommand = {
     name: 'info',
     description: 'Show detailed information about a pattern',
     options: [
@@ -403,79 +325,69 @@ export var storeInfoCommand = {
     examples: [
         { command: 'claude-flow hooks transfer store info -n seraphine-genesis', description: 'Show pattern info' },
     ],
-    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*/];
+    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 };
+            }
+            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 var storeCommand = {
+export const storeCommand = {
     name: 'store',
     description: 'Pattern marketplace - list, search, download, publish',
     subcommands: [
@@ -491,28 +403,26 @@ export var 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: 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 }];
-        });
-    }); }
+    action: async () => {
+        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 { success: true };
+    },
 };
 export default storeCommand;
 //# sourceMappingURL=transfer-store.js.map