@claude-flow/cli 3.32.1 → 3.32.3

package/dist/src/plugins/tests/test-plugin-store.js

@@ -1,206 +0,0 @@
-#!/usr/bin/env npx tsx
-/**
- * Plugin Store Test Suite
- * Tests IPFS-based plugin registry discovery, search, and operations
- */
-import { createPluginDiscoveryService, searchPlugins, getPluginSearchSuggestions, getPluginTagCloud, getFeaturedPlugins, getTrendingPlugins, getOfficialPlugins, findSimilarPlugins, } from '../store/index.js';
-// Test results tracking
-const results = [];
-function logTest(name, passed, details) {
-    results.push({ test: name, passed, details });
-    const icon = passed ? '✅' : '❌';
-    console.log(`${icon} ${name}${details ? `: ${details}` : ''}`);
-}
-async function runTests() {
-    console.log('');
-    console.log('╔══════════════════════════════════════════════════════════╗');
-    console.log('║        PLUGIN STORE TEST SUITE                           ║');
-    console.log('║        Testing IPFS-Based Registry Discovery             ║');
-    console.log('╚══════════════════════════════════════════════════════════╝');
-    console.log('');
-    // ==========================================================================
-    // 1. DISCOVERY TESTS
-    // ==========================================================================
-    console.log('─── Discovery Tests ───────────────────────────────────────');
-    try {
-        const discovery = createPluginDiscoveryService();
-        logTest('Discovery service created', true);
-        // List registries
-        const registries = discovery.listRegistries();
-        logTest('List registries', registries.length > 0, `Found ${registries.length} registries`);
-        // Discover registry
-        const result = await discovery.discoverRegistry();
-        logTest('Discover registry via IPNS', result.success, result.success
-            ? `Loaded ${result.registry?.plugins.length || 0} plugins`
-            : result.error);
-        // Cache test
-        if (result.success) {
-            const cachedResult = await discovery.discoverRegistry();
-            logTest('Cache hit', cachedResult.fromCache === true, 'Second request from cache');
-        }
-        console.log('');
-        // ==========================================================================
-        // 2. SEARCH TESTS
-        // ==========================================================================
-        console.log('─── Search Tests ──────────────────────────────────────────');
-        if (result.success && result.registry) {
-            const registry = result.registry;
-            // Basic search
-            const basicSearch = searchPlugins(registry);
-            logTest('Basic search', basicSearch.plugins.length > 0, `Found ${basicSearch.total} plugins`);
-            // Query search for plugin-creator
-            const creatorSearch = searchPlugins(registry, { query: 'creator' });
-            logTest('Query search: "creator"', creatorSearch.plugins.length > 0, `Found ${creatorSearch.plugins.length} plugins matching "creator"`);
-            // Verify plugin-creator exists
-            const pluginCreator = creatorSearch.plugins.find(p => p.id === 'plugin-creator');
-            logTest('Plugin Creator found', pluginCreator !== undefined, pluginCreator ? `v${pluginCreator.version} - ${pluginCreator.displayName}` : 'Not found');
-            // Category filter
-            const securitySearch = searchPlugins(registry, { category: 'security' });
-            logTest('Category filter: security', true, `Found ${securitySearch.plugins.length} security plugins`);
-            // Type filter
-            const commandSearch = searchPlugins(registry, { type: 'command' });
-            logTest('Type filter: command', commandSearch.plugins.length > 0, `Found ${commandSearch.plugins.length} command plugins`);
-            // Verified filter
-            const verifiedSearch = searchPlugins(registry, { verified: true });
-            logTest('Verified filter', verifiedSearch.plugins.length > 0, `Verified plugins: ${verifiedSearch.plugins.length}`);
-            // Sort by downloads
-            const sortedSearch = searchPlugins(registry, {
-                sortBy: 'downloads',
-                sortOrder: 'desc',
-            });
-            logTest('Sort by downloads', true, `Top plugin: ${sortedSearch.plugins[0]?.displayName || 'none'} (${sortedSearch.plugins[0]?.downloads || 0} downloads)`);
-            // Pagination
-            const page1 = searchPlugins(registry, { limit: 3, offset: 0 });
-            logTest('Pagination', page1.pageSize === 3, `Page 1 with ${page1.plugins.length} plugins, hasMore: ${page1.hasMore}`);
-            // Search suggestions
-            const suggestions = getPluginSearchSuggestions(registry, 'neu');
-            logTest('Search suggestions', suggestions.length >= 0, `Suggestions for "neu": ${suggestions.slice(0, 3).join(', ') || 'none'}`);
-            // Tag cloud
-            const tagCloud = getPluginTagCloud(registry);
-            logTest('Tag cloud', tagCloud.size > 0, `${tagCloud.size} unique tags`);
-        }
-        console.log('');
-        // ==========================================================================
-        // 3. FEATURED/TRENDING/OFFICIAL TESTS
-        // ==========================================================================
-        console.log('─── Featured/Trending/Official Tests ─────────────────────');
-        if (result.success && result.registry) {
-            const registry = result.registry;
-            // Featured plugins
-            const featured = getFeaturedPlugins(registry);
-            logTest('Featured plugins', featured.length > 0, `${featured.length} featured: ${featured.map(p => p.name).join(', ')}`);
-            // Check plugin-creator is featured
-            const creatorFeatured = featured.some(p => p.id === 'plugin-creator');
-            logTest('Plugin Creator is featured', creatorFeatured, creatorFeatured ? 'Yes' : 'No');
-            // Trending plugins
-            const trending = getTrendingPlugins(registry);
-            logTest('Trending plugins', trending.length > 0, `${trending.length} trending: ${trending.map(p => p.name).join(', ')}`);
-            // Official plugins
-            const official = getOfficialPlugins(registry);
-            logTest('Official plugins', official.length > 0, `${official.length} official plugins`);
-            // Similar plugins
-            const similar = findSimilarPlugins(registry, '@claude-flow/neural', 3);
-            logTest('Similar plugins', similar.length >= 0, `Similar to @claude-flow/neural: ${similar.map(p => p.name).join(', ') || 'none'}`);
-        }
-        console.log('');
-        // ==========================================================================
-        // 4. PLUGIN DETAILS TEST
-        // ==========================================================================
-        console.log('─── Plugin Details Test ───────────────────────────────────');
-        if (result.success && result.registry) {
-            const pluginCreator = result.registry.plugins.find(p => p.id === 'plugin-creator');
-            if (pluginCreator) {
-                logTest('Plugin Creator details', true);
-                console.log('');
-                console.log('   Plugin Creator Pro Details:');
-                console.log(`   ├─ ID: ${pluginCreator.id}`);
-                console.log(`   ├─ Version: ${pluginCreator.version}`);
-                console.log(`   ├─ CID: ${pluginCreator.cid}`);
-                console.log(`   ├─ Size: ${(pluginCreator.size / 1024).toFixed(1)} KB`);
-                console.log(`   ├─ Downloads: ${pluginCreator.downloads.toLocaleString()}`);
-                console.log(`   ├─ Rating: ${pluginCreator.rating}★ (${pluginCreator.ratingCount} ratings)`);
-                console.log(`   ├─ Trust: ${pluginCreator.trustLevel}`);
-                console.log(`   ├─ Verified: ${pluginCreator.verified ? '✓' : '✗'}`);
-                console.log(`   ├─ Commands: ${pluginCreator.commands.length}`);
-                pluginCreator.commands.forEach(cmd => {
-                    console.log(`   │  └─ ${cmd}`);
-                });
-                console.log(`   ├─ Hooks: ${pluginCreator.hooks.length}`);
-                pluginCreator.hooks.forEach(hook => {
-                    console.log(`   │  └─ ${hook}`);
-                });
-                console.log(`   ├─ Permissions: ${pluginCreator.permissions.join(', ')}`);
-                console.log(`   ├─ Security Audit: ${pluginCreator.securityAudit ? '✓ Passed' : 'None'}`);
-                console.log(`   └─ License: ${pluginCreator.license}`);
-                console.log('');
-            }
-        }
-        // ==========================================================================
-        // 5. INTEGRATION TEST
-        // ==========================================================================
-        console.log('─── Integration Test ──────────────────────────────────────');
-        // Full workflow: discover -> search -> get details
-        const store = createPluginDiscoveryService();
-        const discoverResult = await store.discoverRegistry();
-        if (discoverResult.success && discoverResult.registry) {
-            const searchResult = searchPlugins(discoverResult.registry, {
-                query: 'plugin creator',
-            });
-            if (searchResult.plugins.length > 0) {
-                const plugin = searchResult.plugins[0];
-                logTest('Full workflow', true, `Discover → Search → Found "${plugin.displayName}" ready to download`);
-            }
-            else {
-                logTest('Full workflow', true, 'Discover → Search completed');
-            }
-        }
-    }
-    catch (error) {
-        console.error('Test error:', error);
-        logTest('Test suite', false, `Error: ${error}`);
-    }
-    // ==========================================================================
-    // SUMMARY
-    // ==========================================================================
-    console.log('');
-    console.log('═══════════════════════════════════════════════════════════');
-    console.log('                      TEST SUMMARY                          ');
-    console.log('═══════════════════════════════════════════════════════════');
-    console.log('');
-    const passed = results.filter(r => r.passed).length;
-    const failed = results.filter(r => !r.passed).length;
-    const total = results.length;
-    console.log(`   Total Tests: ${total}`);
-    console.log(`   ✅ Passed: ${passed}`);
-    console.log(`   ❌ Failed: ${failed}`);
-    console.log('');
-    if (failed === 0) {
-        console.log('   🎉 All tests passed!');
-        console.log('');
-        console.log('   📦 Plugin Store Features Verified:');
-        console.log('      - Registry discovery via IPNS');
-        console.log('      - Plugin search with filters');
-        console.log('      - Featured/Trending/Official listings');
-        console.log('      - Plugin Creator Pro available for download');
-        console.log('');
-        console.log('   🔧 Plugin Creator Pro Commands:');
-        console.log('      - plugin-creator new       Create new plugin');
-        console.log('      - plugin-creator template  Use template');
-        console.log('      - plugin-creator validate  Validate plugin');
-        console.log('      - plugin-creator test      Run tests');
-        console.log('      - plugin-creator build     Build plugin');
-        console.log('      - plugin-creator publish   Publish to IPFS');
-        console.log('      - plugin-creator watch     Hot-reload dev mode');
-        console.log('');
-    }
-    else {
-        console.log('   ⚠️ Some tests failed. Please review the output above.');
-    }
-    process.exit(failed > 0 ? 1 : 0);
-}
-// Run tests
-runTests().catch(error => {
-    console.error('Fatal error:', error);
-    process.exit(1);
-});
-//# sourceMappingURL=test-plugin-store.js.map

package/dist/src/production/circuit-breaker.d.ts

@@ -1,101 +0,0 @@
-/**
- * Production Circuit Breaker
- *
- * Implements the circuit breaker pattern to prevent cascading failures:
- * - Closed: Normal operation
- * - Open: Failing fast, not calling service
- * - Half-Open: Testing if service recovered
- *
- * @module @claude-flow/cli/production/circuit-breaker
- */
-export type CircuitState = 'closed' | 'open' | 'half-open';
-export interface CircuitBreakerConfig {
-    failureThreshold: number;
-    resetTimeoutMs: number;
-    successThreshold: number;
-    failureWindowMs: number;
-    halfOpenRequestPercentage: number;
-    onStateChange?: (from: CircuitState, to: CircuitState) => void;
-    onOpen?: (failures: number) => void;
-    onClose?: () => void;
-}
-export interface CircuitStats {
-    state: CircuitState;
-    failures: number;
-    successes: number;
-    lastFailure: Date | null;
-    lastSuccess: Date | null;
-    stateChangedAt: Date;
-    totalRequests: number;
-    totalFailures: number;
-    totalSuccesses: number;
-}
-export declare class CircuitBreaker {
-    private config;
-    private state;
-    private failures;
-    private successCount;
-    private stateChangedAt;
-    private totalRequests;
-    private totalFailures;
-    private totalSuccesses;
-    private lastFailure;
-    private lastSuccess;
-    constructor(config?: Partial<CircuitBreakerConfig>);
-    /**
-     * Get current circuit state
-     */
-    getState(): CircuitState;
-    /**
-     * Check if request is allowed
-     */
-    isAllowed(): boolean;
-    /**
-     * Execute a function through the circuit breaker
-     */
-    execute<T>(fn: () => Promise<T>): Promise<T>;
-    /**
-     * Record a successful operation
-     */
-    recordSuccess(): void;
-    /**
-     * Record a failed operation
-     */
-    recordFailure(): void;
-    /**
-     * Manually open the circuit
-     */
-    open(): void;
-    /**
-     * Manually close the circuit
-     */
-    close(): void;
-    /**
-     * Reset the circuit breaker
-     */
-    reset(): void;
-    /**
-     * Get circuit statistics
-     */
-    getStats(): CircuitStats;
-    /**
-     * Get failure rate
-     */
-    getFailureRate(): number;
-    private checkStateTransition;
-    private transitionTo;
-}
-/**
- * Get or create a circuit breaker by name
- */
-export declare function getCircuitBreaker(name: string, config?: Partial<CircuitBreakerConfig>): CircuitBreaker;
-/**
- * Get all circuit breaker stats
- */
-export declare function getAllCircuitStats(): Record<string, CircuitStats>;
-/**
- * Reset all circuit breakers
- */
-export declare function resetAllCircuits(): void;
-export default CircuitBreaker;
-//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/src/production/circuit-breaker.js

@@ -1,241 +0,0 @@
-/**
- * Production Circuit Breaker
- *
- * Implements the circuit breaker pattern to prevent cascading failures:
- * - Closed: Normal operation
- * - Open: Failing fast, not calling service
- * - Half-Open: Testing if service recovered
- *
- * @module @claude-flow/cli/production/circuit-breaker
- */
-// ============================================================================
-// Default Configuration
-// ============================================================================
-const DEFAULT_CONFIG = {
-    failureThreshold: 5,
-    resetTimeoutMs: 30000,
-    successThreshold: 3,
-    failureWindowMs: 60000,
-    halfOpenRequestPercentage: 0.1,
-};
-// ============================================================================
-// Circuit Breaker Implementation
-// ============================================================================
-export class CircuitBreaker {
-    config;
-    state = 'closed';
-    failures = [];
-    successCount = 0;
-    stateChangedAt = Date.now();
-    totalRequests = 0;
-    totalFailures = 0;
-    totalSuccesses = 0;
-    lastFailure = null;
-    lastSuccess = null;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Get current circuit state
-     */
-    getState() {
-        this.checkStateTransition();
-        return this.state;
-    }
-    /**
-     * Check if request is allowed
-     */
-    isAllowed() {
-        this.checkStateTransition();
-        switch (this.state) {
-            case 'closed':
-                return true;
-            case 'open':
-                return false;
-            case 'half-open':
-                // Allow a percentage of requests through
-                return Math.random() < this.config.halfOpenRequestPercentage;
-            default:
-                return true;
-        }
-    }
-    /**
-     * Execute a function through the circuit breaker
-     */
-    async execute(fn) {
-        if (!this.isAllowed()) {
-            throw new Error('Circuit breaker is open. Service temporarily unavailable.');
-        }
-        this.totalRequests++;
-        try {
-            const result = await fn();
-            this.recordSuccess();
-            return result;
-        }
-        catch (error) {
-            this.recordFailure();
-            throw error;
-        }
-    }
-    /**
-     * Record a successful operation
-     */
-    recordSuccess() {
-        this.totalSuccesses++;
-        this.lastSuccess = new Date();
-        if (this.state === 'half-open') {
-            this.successCount++;
-            if (this.successCount >= this.config.successThreshold) {
-                this.transitionTo('closed');
-            }
-        }
-        // Reset failure count on success in closed state
-        if (this.state === 'closed') {
-            this.failures = [];
-        }
-    }
-    /**
-     * Record a failed operation
-     */
-    recordFailure() {
-        const now = Date.now();
-        this.totalFailures++;
-        this.lastFailure = new Date();
-        // Add failure timestamp
-        this.failures.push(now);
-        // Clean old failures outside window
-        this.failures = this.failures.filter(t => t > now - this.config.failureWindowMs);
-        // Check if we should open the circuit
-        if (this.state === 'closed' && this.failures.length >= this.config.failureThreshold) {
-            this.transitionTo('open');
-            if (this.config.onOpen) {
-                this.config.onOpen(this.failures.length);
-            }
-        }
-        // If half-open and we fail, go back to open
-        if (this.state === 'half-open') {
-            this.transitionTo('open');
-        }
-    }
-    /**
-     * Manually open the circuit
-     */
-    open() {
-        if (this.state !== 'open') {
-            this.transitionTo('open');
-        }
-    }
-    /**
-     * Manually close the circuit
-     */
-    close() {
-        if (this.state !== 'closed') {
-            this.transitionTo('closed');
-        }
-    }
-    /**
-     * Reset the circuit breaker
-     */
-    reset() {
-        this.state = 'closed';
-        this.failures = [];
-        this.successCount = 0;
-        this.stateChangedAt = Date.now();
-        this.totalRequests = 0;
-        this.totalFailures = 0;
-        this.totalSuccesses = 0;
-        this.lastFailure = null;
-        this.lastSuccess = null;
-    }
-    /**
-     * Get circuit statistics
-     */
-    getStats() {
-        return {
-            state: this.state,
-            failures: this.failures.length,
-            successes: this.successCount,
-            lastFailure: this.lastFailure,
-            lastSuccess: this.lastSuccess,
-            stateChangedAt: new Date(this.stateChangedAt),
-            totalRequests: this.totalRequests,
-            totalFailures: this.totalFailures,
-            totalSuccesses: this.totalSuccesses,
-        };
-    }
-    /**
-     * Get failure rate
-     */
-    getFailureRate() {
-        if (this.totalRequests === 0)
-            return 0;
-        return this.totalFailures / this.totalRequests;
-    }
-    // ============================================================================
-    // Private Methods
-    // ============================================================================
-    checkStateTransition() {
-        const now = Date.now();
-        if (this.state === 'open') {
-            // Check if we should transition to half-open
-            if (now - this.stateChangedAt >= this.config.resetTimeoutMs) {
-                this.transitionTo('half-open');
-            }
-        }
-    }
-    transitionTo(newState) {
-        const oldState = this.state;
-        if (oldState === newState)
-            return;
-        this.state = newState;
-        this.stateChangedAt = Date.now();
-        // Reset counters on state change
-        if (newState === 'half-open') {
-            this.successCount = 0;
-        }
-        if (newState === 'closed') {
-            this.failures = [];
-            this.successCount = 0;
-            if (this.config.onClose) {
-                this.config.onClose();
-            }
-        }
-        // Notify state change
-        if (this.config.onStateChange) {
-            this.config.onStateChange(oldState, newState);
-        }
-    }
-}
-// ============================================================================
-// Circuit Breaker Registry
-// ============================================================================
-const circuitBreakers = new Map();
-/**
- * Get or create a circuit breaker by name
- */
-export function getCircuitBreaker(name, config) {
-    if (!circuitBreakers.has(name)) {
-        circuitBreakers.set(name, new CircuitBreaker(config));
-    }
-    return circuitBreakers.get(name);
-}
-/**
- * Get all circuit breaker stats
- */
-export function getAllCircuitStats() {
-    const stats = {};
-    for (const [name, breaker] of circuitBreakers) {
-        stats[name] = breaker.getStats();
-    }
-    return stats;
-}
-/**
- * Reset all circuit breakers
- */
-export function resetAllCircuits() {
-    for (const breaker of circuitBreakers.values()) {
-        breaker.reset();
-    }
-}
-export default CircuitBreaker;
-//# sourceMappingURL=circuit-breaker.js.map

package/dist/src/production/error-handler.d.ts

@@ -1,92 +0,0 @@
-/**
- * Production Error Handling
- *
- * Provides standardized error handling with:
- * - Error classification
- * - Sanitization (no sensitive data leak)
- * - Structured error responses
- * - Error aggregation and reporting
- *
- * @module @claude-flow/cli/production/error-handler
- */
-export interface ErrorContext {
-    operation: string;
-    tool?: string;
-    input?: Record<string, unknown>;
-    userId?: string;
-    agentId?: string;
-    requestId?: string;
-    timestamp: string;
-}
-export interface ErrorHandlerConfig {
-    includeStack: boolean;
-    sanitize: boolean;
-    reportToMonitoring: boolean;
-    maxErrorsPerMinute: number;
-    errorCategories: Record<string, string[]>;
-}
-export type ErrorCategory = 'validation' | 'authentication' | 'authorization' | 'not_found' | 'rate_limit' | 'timeout' | 'circuit_open' | 'external_service' | 'internal' | 'unknown';
-export interface StructuredError {
-    success: false;
-    error: {
-        code: string;
-        message: string;
-        category: ErrorCategory;
-        retryable: boolean;
-        retryAfterMs?: number;
-        details?: Record<string, unknown>;
-    };
-    context?: Partial<ErrorContext>;
-    timestamp: string;
-}
-export declare class ErrorHandler {
-    private config;
-    private errorCounts;
-    private errorLog;
-    private maxLogSize;
-    constructor(config?: Partial<ErrorHandlerConfig>);
-    /**
-     * Classify an error into a category
-     */
-    classifyError(error: Error | string): ErrorCategory;
-    /**
-     * Check if an error category is retryable
-     */
-    isRetryable(category: ErrorCategory): boolean;
-    /**
-     * Sanitize input to remove sensitive data
-     */
-    sanitize(input: Record<string, unknown>): Record<string, unknown>;
-    /**
-     * Handle an error and return a structured response
-     */
-    handle(error: Error | string, context?: Partial<ErrorContext>): StructuredError;
-    /**
-     * Wrap a handler with error handling
-     */
-    wrap<T extends (...args: unknown[]) => Promise<unknown>>(handler: T, context: Partial<ErrorContext>): T;
-    /**
-     * Get error statistics
-     */
-    getStats(): {
-        totalErrors: number;
-        byCategory: Record<string, number>;
-        recentErrors: StructuredError[];
-        errorRate: number;
-    };
-    /**
-     * Clear error log
-     */
-    clearLog(): void;
-    private getErrorCode;
-    private getRetryDelay;
-    private sanitizeMessage;
-    private trackError;
-    private logError;
-}
-/**
- * Wrap a handler with error handling (convenience function)
- */
-export declare function withErrorHandling<T extends (...args: unknown[]) => Promise<unknown>>(handler: T, context?: Partial<ErrorContext>): T;
-export default ErrorHandler;
-//# sourceMappingURL=error-handler.d.ts.map