@claude-flow/plugin-perf-optimizer 3.0.0-alpha.1

package/README.md

@@ -0,0 +1,276 @@
+# @claude-flow/plugin-performance-optimizer
+
+[![npm version](https://img.shields.io/npm/v/@claude-flow/plugin-performance-optimizer.svg)](https://www.npmjs.com/package/@claude-flow/plugin-performance-optimizer)
+[![npm downloads](https://img.shields.io/npm/dm/@claude-flow/plugin-performance-optimizer.svg)](https://www.npmjs.com/package/@claude-flow/plugin-performance-optimizer)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A comprehensive performance optimization plugin combining sparse inference for efficient trace analysis with graph neural networks for dependency chain optimization. The plugin enables intelligent bottleneck detection, memory leak identification, N+1 query detection, and bundle size optimization while providing explainable recommendations based on historical performance patterns.
+
+## Features
+
+- **Bottleneck Detection**: Identify performance bottlenecks using GNN-based dependency analysis
+- **Memory Analysis**: Detect memory leaks, retention chains, and GC pressure points
+- **Query Optimization**: Detect N+1 queries, missing indexes, and slow joins
+- **Bundle Optimization**: Analyze and optimize JavaScript bundle size with tree shaking and code splitting
+- **Configuration Optimization**: Learn optimal configurations from workload patterns using SONA
+
+## Installation
+
+### npm
+
+```bash
+npm install @claude-flow/plugin-performance-optimizer
+```
+
+### CLI
+
+```bash
+npx claude-flow plugins install --name @claude-flow/plugin-performance-optimizer
+```
+
+## Quick Start
+
+```typescript
+import { PerfOptimizerPlugin } from '@claude-flow/plugin-performance-optimizer';
+
+// Initialize the plugin
+const plugin = new PerfOptimizerPlugin();
+await plugin.initialize();
+
+// Detect performance bottlenecks
+const bottlenecks = await plugin.detectBottlenecks({
+  traceData: {
+    format: 'otlp',
+    spans: traceSpans,
+    metrics: performanceMetrics
+  },
+  analysisScope: ['cpu', 'memory', 'database'],
+  threshold: {
+    latencyP95: 500,  // 500ms
+    throughput: 1000,
+    errorRate: 0.01
+  }
+});
+
+console.log('Detected bottlenecks:', bottlenecks);
+```
+
+## MCP Tools
+
+### 1. `perf/bottleneck-detect`
+
+Detect performance bottlenecks using GNN-based dependency analysis.
+
+```typescript
+// Example usage via MCP
+const result = await mcp.call('perf/bottleneck-detect', {
+  traceData: {
+    format: 'chrome_devtools',
+    spans: chromeTraceSpans,
+    metrics: { renderTime: 150, scriptTime: 200 }
+  },
+  analysisScope: ['cpu', 'render', 'network'],
+  threshold: {
+    latencyP95: 100,
+    throughput: 60
+  }
+});
+```
+
+**Returns:** List of identified bottlenecks with severity, location, and recommended fixes.
+
+### 2. `perf/memory-analyze`
+
+Analyze memory usage patterns and detect potential leaks.
+
+```typescript
+const result = await mcp.call('perf/memory-analyze', {
+  heapSnapshot: '/path/to/heap-snapshot.heapsnapshot',
+  timeline: memoryTimelineData,
+  analysis: ['leak_detection', 'retention_analysis', 'gc_pressure'],
+  compareBaseline: '/path/to/baseline-snapshot.heapsnapshot'
+});
+```
+
+**Returns:** Memory analysis report with leak candidates, retention chains, and optimization suggestions.
+
+### 3. `perf/query-optimize`
+
+Detect N+1 queries and suggest database optimizations.
+
+```typescript
+const result = await mcp.call('perf/query-optimize', {
+  queries: [
+    { sql: 'SELECT * FROM users WHERE id = ?', duration: 5, resultSize: 1 },
+    { sql: 'SELECT * FROM orders WHERE user_id = ?', duration: 3, resultSize: 10 }
+  ],
+  patterns: ['n_plus_1', 'missing_index', 'slow_join'],
+  suggestIndexes: true
+});
+```
+
+**Returns:** Detected query anti-patterns with suggested batch alternatives and index recommendations.
+
+### 4. `perf/bundle-optimize`
+
+Analyze and optimize JavaScript bundle size.
+
+```typescript
+const result = await mcp.call('perf/bundle-optimize', {
+  bundleStats: '/path/to/webpack-stats.json',
+  analysis: ['tree_shaking', 'code_splitting', 'duplicate_deps', 'large_modules'],
+  targets: {
+    maxSize: 250,  // 250KB
+    maxChunks: 10
+  }
+});
+```
+
+**Returns:** Bundle analysis with optimization recommendations for tree shaking, code splitting, and dependency deduplication.
+
+### 5. `perf/config-optimize`
+
+Suggest optimal configurations based on workload patterns using SONA learning.
+
+```typescript
+const result = await mcp.call('perf/config-optimize', {
+  workloadProfile: {
+    type: 'api',
+    metrics: { requestsPerSecond: 1000, avgLatency: 50 },
+    constraints: { maxMemory: '4GB', maxCpu: 4 }
+  },
+  configSpace: {
+    poolSize: { type: 'number', range: [10, 100], current: 25 },
+    cacheSize: { type: 'number', range: [100, 1000], current: 200 }
+  },
+  objective: 'latency'
+});
+```
+
+**Returns:** Optimized configuration values with expected performance improvements.
+
+## Configuration Options
+
+```typescript
+interface PerfOptimizerConfig {
+  // WASM memory limit (default: 2GB)
+  memoryLimit: number;
+
+  // Analysis timeout in seconds (default: 300)
+  analysisTimeout: number;
+
+  // Enable SONA learning for configuration optimization
+  enableSONALearning: boolean;
+
+  // Supported trace formats
+  supportedFormats: ('otlp' | 'chrome_devtools' | 'jaeger' | 'zipkin')[];
+
+  // Performance thresholds for alerting
+  thresholds: {
+    latencyP95: number;
+    throughput: number;
+    errorRate: number;
+  };
+}
+```
+
+## Performance Targets
+
+| Metric | Target | Improvement vs Baseline |
+|--------|--------|------------------------|
+| Trace analysis (1M spans) | <5s | 24x faster |
+| Memory analysis (1GB heap) | <30s | 10x faster |
+| Query pattern detection (10K queries) | <1s | 600x faster |
+| Bundle analysis (10MB) | <10s | 6x faster |
+| Config optimization | <1min convergence | 1440x+ faster |
+
+## Security Considerations
+
+- **Trace Data Sanitization**: Automatically sanitizes sensitive data (passwords, tokens, cookies) from trace data before processing
+- **Query Parse-Only**: SQL queries are parsed and analyzed but never executed
+- **WASM Sandboxing**: All analysis runs in isolated WASM sandbox with 2GB memory limit and no network access
+- **Path Validation**: Bundle stats paths are validated to prevent path traversal attacks
+- **Input Validation**: All inputs validated with Zod schemas to prevent injection attacks
+- **No Code Execution**: Performance suggestions are recommendations only - no automatic code modification
+
+### WASM Security Constraints
+
+| Constraint | Value | Rationale |
+|------------|-------|-----------|
+| Memory Limit | 2GB max | Handle large trace datasets |
+| CPU Time Limit | 300 seconds | Allow deep performance analysis |
+| No Network Access | Enforced | Prevent data exfiltration |
+| No File System Write | Enforced | Read-only analysis mode |
+| Sandboxed Paths | Validated prefixes only | Prevent path traversal |
+
+### Input Limits
+
+| Input | Limit |
+|-------|-------|
+| Max spans per trace | 1,000,000 |
+| Max query size | 10KB |
+| Max queries per batch | 10,000 |
+| Max heap snapshot size | 1GB |
+| Max bundle stats size | 50MB |
+| CPU time limit | 300 seconds |
+
+### Rate Limiting
+
+```typescript
+const rateLimits = {
+  'perf/bottleneck-detect': { requestsPerMinute: 10, maxConcurrent: 2 },
+  'perf/memory-analyze': { requestsPerMinute: 5, maxConcurrent: 1 },
+  'perf/query-optimize': { requestsPerMinute: 30, maxConcurrent: 3 },
+  'perf/bundle-optimize': { requestsPerMinute: 10, maxConcurrent: 2 },
+  'perf/config-optimize': { requestsPerMinute: 5, maxConcurrent: 1 }
+};
+```
+
+## Dependencies
+
+- `ruvector-sparse-inference-wasm` - Efficient sparse performance trace processing
+- `ruvector-gnn-wasm` - Dependency chain analysis and critical path detection
+- `micro-hnsw-wasm` - Similar performance pattern matching
+- `ruvector-fpga-transformer-wasm` - Fast transformer inference for trace analysis
+- `sona` - Learning optimal configurations from historical data
+
+## Supported Formats
+
+| Category | Formats |
+|----------|---------|
+| Tracing | OpenTelemetry, Jaeger, Zipkin, Chrome DevTools |
+| Profiling | Chrome CPU Profile, Node.js Profile, pprof |
+| Memory | Chrome Heap Snapshot, Node.js Heap |
+| Bundles | Webpack Stats, Vite Stats, Rollup |
+
+## Related Plugins
+
+| Plugin | Description | Use Case |
+|--------|-------------|----------|
+| [@claude-flow/plugin-code-intelligence](../code-intelligence) | Code analysis | Identify code causing performance issues |
+| [@claude-flow/plugin-test-intelligence](../test-intelligence) | Test optimization | Performance regression test selection |
+| [@claude-flow/plugin-financial-risk](../financial-risk) | Risk analysis | Trading system latency optimization |
+
+## License
+
+MIT License
+
+Copyright (c) 2026 Claude Flow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bridges/fpga-bridge.d.ts

@@ -0,0 +1,81 @@
+/**
+ * FPGA Transformer Bridge for Performance Optimizer
+ *
+ * Provides fast configuration optimization using FPGA-accelerated
+ * transformer inference from ruvector-fpga-transformer-wasm.
+ */
+import type { FpgaBridgeInterface, WorkloadProfile, ConfigOptimization } from '../types.js';
+/**
+ * FPGA transformer configuration
+ */
+interface FpgaConfig {
+    modelSize: 'small' | 'medium' | 'large';
+    searchIterations: number;
+    explorationRate: number;
+    bayesianOptimization: boolean;
+}
+/**
+ * FPGA Transformer Bridge Implementation
+ *
+ * Uses FPGA-accelerated transformers for:
+ * - Configuration space exploration
+ * - Performance prediction
+ * - Optimal configuration search
+ */
+export declare class PerfFpgaBridge implements FpgaBridgeInterface {
+    readonly name = "perf-optimizer-fpga";
+    readonly version = "0.1.0";
+    private status;
+    private config;
+    private performanceModel;
+    private configHistory;
+    private baselinePerformance;
+    constructor(config?: Partial<FpgaConfig>);
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    isReady(): boolean;
+    /**
+     * Optimize configuration for workload
+     *
+     * Uses SONA-based learning to find optimal configuration parameters.
+     */
+    optimizeConfig(workload: WorkloadProfile, configSpace: Record<string, unknown>): Promise<ConfigOptimization>;
+    /**
+     * Predict performance for configuration
+     *
+     * Uses the learned performance model to estimate performance metrics.
+     */
+    predictPerformance(config: Record<string, unknown>, workload: WorkloadProfile): Promise<number>;
+    /**
+     * Search for optimal configuration
+     *
+     * Uses Bayesian optimization or grid search to find the best configuration.
+     */
+    searchOptimalConfig(objective: string, constraints: Record<string, number>): Promise<Record<string, unknown>>;
+    /**
+     * Learn from performance feedback
+     */
+    learnFromFeedback(config: Record<string, unknown>, actualPerformance: number): void;
+    private initializePerformanceModel;
+    private optimizeParameter;
+    private getOptimalRatio;
+    private suggestBooleanConfig;
+    private suggestEnumConfig;
+    private predictImprovement;
+    private getWorkloadBaseline;
+    private getParameterImpact;
+    private embedConfig;
+    private embeddingToKey;
+    private defineSearchSpace;
+    private bayesianSearch;
+    private gridSearch;
+    private getBestHistoricalValue;
+    private evaluateConfig;
+    private hashString;
+}
+/**
+ * Create a new FPGA bridge instance
+ */
+export declare function createPerfFpgaBridge(config?: Partial<FpgaConfig>): PerfFpgaBridge;
+export {};
+//# sourceMappingURL=fpga-bridge.d.ts.map

package/dist/bridges/fpga-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fpga-bridge.d.ts","sourceRoot":"","sources":["../../src/bridges/fpga-bridge.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAEnB,MAAM,aAAa,CAAC;AAOrB;;GAEG;AACH,UAAU,UAAU;IAClB,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;IACxC,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,oBAAoB,EAAE,OAAO,CAAC;CAC/B;AAYD;;;;;;;GAOG;AACH,qBAAa,cAAe,YAAW,mBAAmB;IACxD,QAAQ,CAAC,IAAI,yBAAyB;IACtC,QAAQ,CAAC,OAAO,WAAW;IAE3B,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,gBAAgB,CAAkC;IAC1D,OAAO,CAAC,aAAa,CAAiE;IACtF,OAAO,CAAC,mBAAmB,CAAkC;gBAEjD,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC;IAIlC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BrB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B,OAAO,IAAI,OAAO;IAIlB;;;;OAIG;IACG,cAAc,CAClB,QAAQ,EAAE,eAAe,EACzB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,OAAO,CAAC,kBAAkB,CAAC;IAoC9B;;;;OAIG;IACG,kBAAkB,CACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,CAAC;IA6BlB;;;;OAIG;IACG,mBAAmB,CACvB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAuBnC;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,EAAE,MAAM,GAAG,IAAI;IAcnF,OAAO,CAAC,0BAA0B;IAyBlC,OAAO,CAAC,iBAAiB;IA6CzB,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,oBAAoB;IAmB5B,OAAO,CAAC,iBAAiB;IAoBzB,OAAO,CAAC,kBAAkB;IAuC1B,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,kBAAkB;IA0B1B,OAAO,CAAC,WAAW;IAwBnB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,iBAAiB;IA+BzB,OAAO,CAAC,cAAc;IAuCtB,OAAO,CAAC,UAAU;IAwClB,OAAO,CAAC,sBAAsB;IAsB9B,OAAO,CAAC,cAAc;IA+BtB,OAAO,CAAC,UAAU;CASnB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,cAAc,CAEjF"}