@claude-flow/cli 3.7.0-alpha.8 → 3.7.0-alpha.81

package/.claude/skills/secure-review.md

@@ -1,181 +0,0 @@
----
-name: secure-review
-version: 1.0.0
-description: Security-focused code review with AI manipulation detection
-author: rUv
-tags: [security, code-review, aidefence]
-
-invocation:
-  - /secure-review
-  - /security-review
-
-requires:
-  - "@claude-flow/aidefence"
----
-
-# Secure Review Skill
-
-Perform security-focused code reviews that include AI manipulation detection, credential scanning, and security best practice validation.
-
-## Commands
-
-### `/secure-review <file-or-directory>`
-Review code for security issues including:
-- Hardcoded credentials
-- Prompt injection vulnerabilities
-- Unsafe input handling
-- Security anti-patterns
-
-### `/secure-review --quick <file>`
-Quick security scan without detailed analysis.
-
-### `/secure-review --fix <file>`
-Review and suggest fixes for security issues.
-
----
-
-## Execution Instructions
-
-When `/secure-review` is invoked:
-
-### Step 1: Initialize Security Tools
-
-```typescript
-import { createAIDefence } from '@claude-flow/aidefence';
-
-const aidefence = createAIDefence({ enableLearning: true });
-```
-
-### Step 2: Read and Analyze Files
-
-For each file to review:
-
-1. **Read the file** using the Read tool
-2. **Scan for PII/Credentials**:
-```typescript
-const piiResult = aidefence.hasPII(fileContent);
-if (piiResult) {
-  findings.push({
-    type: 'pii',
-    severity: 'high',
-    message: 'Potential credentials or PII detected',
-    file: filePath
-  });
-}
-```
-
-3. **Check for dangerous patterns**:
-```typescript
-const dangerousPatterns = [
-  { pattern: /eval\s*\(/, message: 'Unsafe eval() usage', severity: 'critical' },
-  { pattern: /innerHTML\s*=/, message: 'Potential XSS via innerHTML', severity: 'high' },
-  { pattern: /shell:\s*true/, message: 'Shell injection risk', severity: 'critical' },
-  { pattern: /dangerouslySetInnerHTML/, message: 'Dangerous HTML injection', severity: 'high' },
-  { pattern: /password.*=.*['"][^'"]+['"]/, message: 'Hardcoded password', severity: 'critical' },
-];
-
-for (const { pattern, message, severity } of dangerousPatterns) {
-  const match = fileContent.match(pattern);
-  if (match) {
-    findings.push({ type: 'security', severity, message, file: filePath, line: getLineNumber(match) });
-  }
-}
-```
-
-4. **Scan for prompt injection in AI code**:
-```typescript
-// If file contains AI/LLM related code
-if (/openai|anthropic|llm|prompt|chat/i.test(fileContent)) {
-  // Check for unsafe prompt construction
-  const unsafePromptPatterns = [
-    /\$\{.*user.*\}/i,  // Template literal with user input
-    /\+ .*input/i,      // String concatenation with input
-    /prompt.*=.*request/i, // Direct request to prompt
-  ];
-
-  for (const pattern of unsafePromptPatterns) {
-    if (pattern.test(fileContent)) {
-      findings.push({
-        type: 'prompt_injection_risk',
-        severity: 'high',
-        message: 'Potential prompt injection vulnerability - user input directly in prompt',
-        file: filePath
-      });
-    }
-  }
-}
-```
-
-### Step 3: Generate Report
-
-```markdown
-## Security Review Report
-
-### Summary
-- Files reviewed: X
-- Critical issues: X
-- High severity: X
-- Medium severity: X
-- Low severity: X
-
-### Findings
-
-#### Critical
-1. **[file.ts:42]** Hardcoded API key detected
-   - **Risk**: Credential exposure
-   - **Fix**: Move to environment variable
-
-#### High
-1. **[api.ts:108]** User input directly concatenated to prompt
-   - **Risk**: Prompt injection vulnerability
-   - **Fix**: Sanitize and validate user input before including in prompts
-
-### Recommendations
-1. Enable input validation at all API boundaries
-2. Use environment variables for all credentials
-3. Implement prompt injection defenses for AI code
-```
-
-### Step 4: Learn from Review
-
-```typescript
-// Store review patterns for learning
-for (const finding of findings) {
-  await aidefence.learnFromDetection(
-    finding.context,
-    { safe: false, threats: [{ type: finding.type, severity: finding.severity }] }
-  );
-}
-```
-
-## Example Output
-
-```
-🔍 Security Review: src/api/
-
-Scanning 12 files...
-
-❌ CRITICAL: src/api/config.ts:15
-   Hardcoded API key: sk-ant-api03...
-   → Move to .env file and use process.env.ANTHROPIC_API_KEY
-
-⚠️ HIGH: src/api/chat.ts:42
-   User input directly in prompt template
-   → Sanitize input: const sanitized = sanitizeForPrompt(userInput)
-
-⚠️ HIGH: src/api/chat.ts:67
-   No input length validation
-   → Add: if (input.length > MAX_INPUT_LENGTH) throw new Error('...')
-
-ℹ️ MEDIUM: src/api/utils.ts:23
-   Using eval() for JSON parsing
-   → Use JSON.parse() instead
-
-📊 Summary: 1 critical, 2 high, 1 medium issues found
-```
-
-## Integration Notes
-
-- Works with `reviewer` agent for comprehensive code reviews
-- Findings are stored in memory for pattern learning
-- Can be triggered automatically via pre-commit hooks

package/.claude/skills/worker-benchmarks/skill.md

@@ -1,135 +0,0 @@
----
-name: worker-benchmarks
-description: Run comprehensive worker system benchmarks and performance analysis
-version: 1.0.0
-invocable: true
-author: agentic-flow
-capabilities:
-  - performance_testing
-  - metrics_collection
-  - optimization_recommendations
----
-
-# Worker Benchmarks Skill
-
-Run comprehensive performance benchmarks for the agentic-flow worker system.
-
-## Quick Start
-
-```bash
-# Run full benchmark suite
-npx agentic-flow workers benchmark
-
-# Run specific benchmark
-npx agentic-flow workers benchmark --type trigger-detection
-npx agentic-flow workers benchmark --type registry
-npx agentic-flow workers benchmark --type agent-selection
-npx agentic-flow workers benchmark --type concurrent
-```
-
-## Benchmark Types
-
-### 1. Trigger Detection (`trigger-detection`)
-Tests keyword detection speed across 12 worker triggers.
-- **Target**: p95 < 5ms
-- **Iterations**: 1000
-- **Metrics**: latency, throughput, histogram
-
-### 2. Worker Registry (`registry`)
-Tests CRUD operations on worker entries.
-- **Target**: p95 < 10ms
-- **Iterations**: 500 creates, gets, updates
-- **Metrics**: per-operation latency breakdown
-
-### 3. Agent Selection (`agent-selection`)
-Tests performance-based agent selection.
-- **Target**: p95 < 1ms
-- **Iterations**: 1000
-- **Metrics**: selection confidence, agent scores
-
-### 4. Model Cache (`cache`)
-Tests model caching performance.
-- **Target**: p95 < 0.5ms
-- **Metrics**: hit rate, cache size, eviction stats
-
-### 5. Concurrent Workers (`concurrent`)
-Tests parallel worker creation and updates.
-- **Target**: < 1000ms for 10 workers
-- **Metrics**: per-worker latency, memory usage
-
-### 6. Memory Key Generation (`memory-keys`)
-Tests memory pattern key generation.
-- **Target**: p95 < 0.1ms
-- **Iterations**: 5000
-- **Metrics**: unique patterns, throughput
-
-## Output Format
-
-```
-═══════════════════════════════════════════════════════════
-📈 BENCHMARK RESULTS
-═══════════════════════════════════════════════════════════
-
-✅ Trigger Detection
-   Operation: detect
-   Count: 1,000
-   Avg: 0.045ms | p95: 0.120ms (target: 5ms)
-   Throughput: 22,222 ops/s
-   Memory Δ: 0.12MB
-
-✅ Worker Registry
-   Operation: crud
-   Count: 1,500
-   Avg: 1.234ms | p95: 3.456ms (target: 10ms)
-   Throughput: 810 ops/s
-   Memory Δ: 2.34MB
-
-───────────────────────────────────────────────────────────
-📊 SUMMARY
-───────────────────────────────────────────────────────────
-Total Tests: 6
-Passed: 6 | Failed: 0
-Avg Latency: 0.567ms
-Total Duration: 2345ms
-Peak Memory: 8.90MB
-═══════════════════════════════════════════════════════════
-```
-
-## Integration with Settings
-
-Benchmark thresholds are configured in `.claude/settings.json`:
-
-```json
-{
-  "performance": {
-    "benchmarkThresholds": {
-      "triggerDetection": { "p95Ms": 5 },
-      "workerRegistry": { "p95Ms": 10 },
-      "agentSelection": { "p95Ms": 1 },
-      "memoryKeyGeneration": { "p95Ms": 0.1 },
-      "concurrentWorkers": { "totalMs": 1000 }
-    }
-  }
-}
-```
-
-## Programmatic Usage
-
-```typescript
-import { workerBenchmarks, runBenchmarks } from 'agentic-flow/workers/worker-benchmarks';
-
-// Run full suite
-const suite = await runBenchmarks();
-console.log(suite.summary);
-
-// Run individual benchmarks
-const triggerResult = await workerBenchmarks.benchmarkTriggerDetection(1000);
-const registryResult = await workerBenchmarks.benchmarkRegistryOperations(500);
-```
-
-## Performance Optimization Tips
-
-1. **Model Cache**: Enable with `CLAUDE_FLOW_MODEL_CACHE_MB=512`
-2. **Parallel Workers**: Enable with `CLAUDE_FLOW_WORKER_PARALLEL=true`
-3. **Warning Suppression**: Enable with `CLAUDE_FLOW_SUPPRESS_WARNINGS=true`
-4. **SQLite WAL Mode**: Automatic for better concurrent performance

package/.claude/skills/worker-integration/skill.md

@@ -1,154 +0,0 @@
----
-name: worker-integration
-description: Worker-Agent integration for intelligent task dispatch and performance tracking
-version: 1.0.0
-invocable: true
-author: agentic-flow
-capabilities:
-  - agent_selection
-  - performance_tracking
-  - memory_coordination
-  - self_learning
----
-
-# Worker-Agent Integration Skill
-
-Intelligent coordination between background workers and specialized agents.
-
-## Quick Start
-
-```bash
-# View agent recommendations for a trigger
-npx agentic-flow workers agents ultralearn
-npx agentic-flow workers agents optimize
-
-# View performance metrics
-npx agentic-flow workers metrics
-
-# View integration stats
-npx agentic-flow workers stats --integration
-```
-
-## Agent Mappings
-
-Workers automatically dispatch to optimal agents based on trigger type:
-
-| Trigger | Primary Agents | Fallback | Pipeline Phases |
-|---------|---------------|----------|-----------------|
-| `ultralearn` | researcher, coder | planner | discovery → patterns → vectorization → summary |
-| `optimize` | performance-analyzer, coder | researcher | static-analysis → performance → patterns |
-| `audit` | security-analyst, tester | reviewer | security → secrets → vulnerability-scan |
-| `benchmark` | performance-analyzer | coder, tester | performance → metrics → report |
-| `testgaps` | tester | coder | discovery → coverage → gaps |
-| `document` | documenter, researcher | coder | api-discovery → patterns → indexing |
-| `deepdive` | researcher, security-analyst | coder | call-graph → deps → trace |
-| `refactor` | coder, reviewer | researcher | complexity → smells → patterns |
-
-## Performance-Based Selection
-
-The system learns from execution history to improve agent selection:
-
-```typescript
-// Agent selection considers:
-// 1. Quality score (0-1)
-// 2. Success rate
-// 3. Average latency
-// 4. Execution count
-
-const { agent, confidence, reasoning } = selectBestAgent('optimize');
-// agent: "performance-analyzer"
-// confidence: 0.87
-// reasoning: "Selected based on 45 executions with 94.2% success"
-```
-
-## Memory Key Patterns
-
-Workers store results using consistent patterns:
-
-```
-{trigger}/{topic}/{phase}
-
-Examples:
-- ultralearn/auth-module/analysis
-- optimize/database/performance
-- audit/payment/vulnerabilities
-- benchmark/api/metrics
-```
-
-## Benchmark Thresholds
-
-Agents are monitored against performance thresholds:
-
-```json
-{
-  "researcher": {
-    "p95_latency": "<500ms",
-    "memory_mb": "<256MB"
-  },
-  "coder": {
-    "p95_latency": "<300ms",
-    "quality_score": ">0.85"
-  },
-  "security-analyst": {
-    "scan_coverage": ">95%",
-    "p95_latency": "<1000ms"
-  }
-}
-```
-
-## Feedback Loop
-
-Workers provide feedback for continuous improvement:
-
-```typescript
-import { workerAgentIntegration } from 'agentic-flow/workers/worker-agent-integration';
-
-// Record execution feedback
-workerAgentIntegration.recordFeedback(
-  'optimize',           // trigger
-  'coder',              // agent
-  true,                 // success
-  245,                  // latency ms
-  0.92                  // quality score
-);
-
-// Check compliance
-const { compliant, violations } = workerAgentIntegration.checkBenchmarkCompliance('coder');
-```
-
-## Integration Statistics
-
-```bash
-$ npx agentic-flow workers stats --integration
-
-Worker-Agent Integration Stats
-══════════════════════════════
-Total Agents:       6
-Tracked Agents:     4
-Total Feedback:     156
-Avg Quality Score:  0.89
-
-Model Cache Stats
-─────────────────
-Hits:     1,234
-Misses:   45
-Hit Rate: 96.5%
-```
-
-## Configuration
-
-Enable integration features in `.claude/settings.json`:
-
-```json
-{
-  "workers": {
-    "enabled": true,
-    "parallel": true,
-    "memoryDepositEnabled": true,
-    "agentMappings": {
-      "ultralearn": ["researcher", "coder"],
-      "optimize": ["performance-analyzer", "coder"]
-    }
-  }
-}
-```

package/dist/src/ruvector/flash-attention.d.ts

@@ -1,195 +0,0 @@
-/**
- * Flash Attention Implementation for RuVector Intelligence System
- *
- * Implements block-wise attention computation for faster similarity calculations.
- * Achieves O(N) memory instead of O(N^2) through tiling strategy.
- *
- * Key optimizations:
- * - Block-wise computation to fit in L1 cache
- * - Fused softmax-matmul operations
- * - Float32Array for all operations
- * - Online softmax for numerical stability
- *
- * Target: 2-5x speedup on CPU vs naive attention
- *
- * Created with love by ruv.io
- */
-export interface FlashAttentionConfig {
-    /** Block size for tiling (32-64 optimal for CPU L1 cache) */
-    blockSize: number;
-    /** Number of dimensions in embedding vectors */
-    dimensions: number;
-    /** Temperature for softmax scaling */
-    temperature: number;
-    /** Enable numerical stability optimizations */
-    useStableMode: boolean;
-    /** Use optimized CPU path (default: true) */
-    useCPUOptimizations: boolean;
-}
-export interface AttentionResult {
-    /** Output vectors after attention */
-    output: Float32Array[];
-    /** Attention weights (optional, for debugging) */
-    weights?: Float32Array[];
-    /** Computation time in milliseconds */
-    computeTimeMs: number;
-}
-export interface BenchmarkResult {
-    /** Naive attention time in milliseconds */
-    naiveTimeMs: number;
-    /** Flash attention time in milliseconds */
-    flashTimeMs: number;
-    /** Speedup factor (naive / flash) */
-    speedup: number;
-    /** Number of vectors benchmarked */
-    numVectors: number;
-    /** Dimensions of vectors */
-    dimensions: number;
-    /** Memory usage estimate for naive (bytes) */
-    naiveMemoryBytes: number;
-    /** Memory usage estimate for flash (bytes) */
-    flashMemoryBytes: number;
-    /** Memory reduction factor */
-    memoryReduction: number;
-}
-export declare class FlashAttention {
-    private config;
-    private lastSpeedup;
-    private benchmarkHistory;
-    private scoreBuffer;
-    private expBuffer;
-    private accumBuffer;
-    constructor(config?: Partial<FlashAttentionConfig>);
-    /**
-     * Main attention computation using Flash Attention algorithm
-     *
-     * @param queries - Query vectors [N x D]
-     * @param keys - Key vectors [M x D]
-     * @param values - Value vectors [M x D]
-     * @returns Attention output [N x D]
-     */
-    attention(queries: Float32Array[], keys: Float32Array[], values: Float32Array[]): AttentionResult;
-    /**
-     * CPU-optimized attention with aggressive optimizations
-     *
-     * Key optimizations:
-     * - Blocked score computation (better cache utilization)
-     * - Top-K sparse attention (only use most relevant keys)
-     * - Pre-allocated buffers to avoid GC pressure
-     * - 8x loop unrolling for dot products
-     * - Fused max-finding during score computation
-     */
-    private cpuOptimizedAttention;
-    /**
-     * Partial dot product using only first N dimensions (for screening)
-     */
-    private partialDotProduct;
-    /**
-     * Partial sort to get top-K elements (QuickSelect-like)
-     * Only ensures first K elements are the largest, not sorted
-     */
-    private partialSort;
-    /**
-     * Swap two indices in array
-     */
-    private swapIndices;
-    /**
-     * Fast dot product with 8x unrolling
-     */
-    private fastDotProduct;
-    /**
-     * Block-wise attention computation (Flash Attention core algorithm)
-     *
-     * Algorithm:
-     * For each block of queries Q_b:
-     *   For each block of keys K_b:
-     *     S_b = Q_b @ K_b.T / sqrt(d)  // Block scores
-     *     P_b = softmax(S_b)           // Block attention
-     *     O_b += P_b @ V_b             // Accumulate output
-     *
-     * @param Q - Query vectors
-     * @param K - Key vectors
-     * @param V - Value vectors
-     * @param blockSize - Block size for tiling
-     */
-    blockAttention(Q: Float32Array[], K: Float32Array[], V: Float32Array[], blockSize: number): Float32Array[];
-    /**
-     * Get the speedup factor from the last benchmark
-     */
-    getSpeedup(): number;
-    /**
-     * Run benchmark comparing naive vs CPU-optimized attention
-     *
-     * @param numVectors - Number of vectors to test
-     * @param dimensions - Dimensions per vector
-     * @param iterations - Number of iterations for averaging
-     */
-    benchmark(numVectors?: number, dimensions?: number, iterations?: number): BenchmarkResult;
-    /**
-     * Get benchmark history
-     */
-    getBenchmarkHistory(): BenchmarkResult[];
-    /**
-     * Get configuration
-     */
-    getConfig(): FlashAttentionConfig;
-    /**
-     * Update configuration
-     */
-    setConfig(config: Partial<FlashAttentionConfig>): void;
-    /**
-     * Naive O(N^2) attention implementation for comparison
-     */
-    private naiveAttention;
-    /**
-     * Compute block of attention scores
-     */
-    private computeBlockScores;
-    /**
-     * Online softmax with output accumulation (key to Flash Attention)
-     *
-     * Uses the online softmax trick to maintain numerical stability
-     * while processing blocks incrementally.
-     */
-    private onlineSoftmaxAccumulate;
-    /**
-     * Compute dot product of two vectors
-     */
-    private dotProduct;
-    /**
-     * Stable softmax implementation
-     */
-    private softmax;
-    /**
-     * Generate random vectors for benchmarking
-     */
-    private generateRandomVectors;
-    /**
-     * Validate input arrays
-     */
-    private validateInputs;
-}
-/**
- * Get singleton FlashAttention instance
- *
- * @param config - Optional configuration (only used on first call)
- * @returns FlashAttention instance
- */
-export declare function getFlashAttention(config?: Partial<FlashAttentionConfig>): FlashAttention;
-/**
- * Reset singleton (for testing)
- */
-export declare function resetFlashAttention(): void;
-/**
- * Compute attention using Flash Attention
- */
-export declare function computeAttention(queries: Float32Array[], keys: Float32Array[], values: Float32Array[], config?: Partial<FlashAttentionConfig>): AttentionResult;
-/**
- * Run Flash Attention benchmark
- */
-export declare function benchmarkFlashAttention(numVectors?: number, dimensions?: number, iterations?: number): BenchmarkResult;
-/**
- * Get current speedup from last benchmark
- */
-export declare function getFlashAttentionSpeedup(): number;
-//# sourceMappingURL=flash-attention.d.ts.map

package/dist/src/ruvector/flash-attention.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flash-attention.d.ts","sourceRoot":"","sources":["../../../src/ruvector/flash-attention.ts"],"names":[],"mappings":"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"}