claude-flow-novice 2.18.5 → 2.18.7

package/.claude/skills/cfn-local-ruvector-accelerator/SKILL.md

@@ -0,0 +1,343 @@
+# Local RuVector Accelerator
+
+## Description
+Lightning-fast local RuVector storage optimized for solo development. No PostgreSQL, no Docker overhead - just pure local file storage with vector search.
+
+## Key Features
+- ⚡ **Instant setup** - No external dependencies
+- 🏎 **Vector search** - Fast semantic similarity using pre-computed embeddings
+- 📁 **Local storage** - All data stays on your machine
+- 🔄 Auto-sync with remote (optional)
+- 🎯 **Pattern sharing** - Share across your projects easily
+
+## Usage
+
+### Quick Setup
+```bash
+# 1. Initialize local RuVector
+./init-local-ruvector.sh
+
+# 2. Index your codebase
+./index-code.sh --path /path/to/project
+
+# 3. Query patterns instantly
+./query-local.sh --pattern "authentication rust" --limit 5
+```
+
+### Development Integration
+```bash
+# Agent uses local RuVector for instant pattern lookup
+./coordinate-generation.sh \
+  --agent-id "dev-$(date +%s)" \
+  --pattern "rust error handling" \
+  --source local  # Use local RuVector, not remote
+```
+
+## Architecture
+
+```
+Local Development
+┌─────────────────────────────────────────────┐
+│          Your Projects                       │
+│   Project A    │    Project B    │    Project C    │
+│   (Auth System) │    (API Server)   │    (CLI Tool)    │
+│       │              │              │              │
+│       └──────────────►│◄──────────────►│◄──────────────┘
+│                          │
+│                Local RuVector Accelerator
+│          ┌───────────────────────────────┐
+│          │  File-Based Storage            │
+│          │  - Vector embeddings (binary)      │
+│          │  - Pattern metadata (JSON)         │
+          │  - SQLite for quick queries           │
+          │  - Index files for search             │
+          │  └───────────────────────────────┘
+│                          │
+│                          ▼
+│          Instant Search & Pattern Lookup
+```
+
+## Implementation
+
+### 1. File Structure
+```
+~/.local-ruvector/
+├── storage/
+│   ├── embeddings.bin          # Pre-computed vector embeddings
+│   ├── metadata/              # Pattern metadata as JSON
+│   └── cache.db                # SQLite index
+├── indexes/
+│   ├── patterns.index          # Fast search index
+│   └── similarities.index       # Similarity precomputed
+└── config/
+    └── settings.json
+```
+
+### 2. Core Components
+
+#### **Fast Embedding Storage**
+```python
+# embeddings_manager.py
+import numpy as np
+import os
+import pickle
+
+class EmbeddingsManager:
+    def __init__(self, storage_path):
+        self.storage_path = storage_path
+        self.embeddings_file = os.path.join(storage_path, 'embeddings.bin')
+        self.dimensions = 1536  # Ada embedding size
+        self.embeddings = None
+
+    def load_embeddings(self):
+        """Load embeddings from file"""
+        if os.path.exists(self.embeddings_file):
+            self.embeddings = np.load(self.embeddings_file)
+        else:
+            self.embeddings = np.zeros((0, self.dimensions))
+
+    def save_embeddings(self):
+        """Save embeddings to file"""
+        np.save(self.embeddings_file, self.embeddings)
+
+    def add_embedding(self, vector: np.ndarray, pattern_id: str):
+        """Add new embedding"""
+        if self.embeddings.shape[0] == 0:
+            self.embeddings = vector.reshape(1, -1)
+        else:
+            self.embeddings = np.vstack([self.embeddings, vector])
+
+        # Save index mapping
+        index_file = os.path.join(self.storage_path, 'embeddings.index')
+        with open(index_file, 'a') as f:
+            f.write(f"{len(self.embeddings)-1}:{pattern_id}\n")
+
+    def get_embedding(self, pattern_id: str) -> np.ndarray:
+        """Get embedding by pattern ID"""
+        # Load index mapping
+        index_file = os.path.join(self.storage_path, 'embeddings.index')
+        if not os.path.exists(index_file):
+            return None
+
+        with open(index_file) as f:
+            for line in f:
+                idx, id_ = line.strip().split(':')
+                if id_ == pattern_id:
+                    return self.embeddings[int(idx)]
+        return None
+```
+
+#### **SQLite Index for Fast Queries**
+```sql
+-- Local SQLite schema for patterns
+CREATE TABLE IF NOT EXISTS patterns (
+    id TEXT PRIMARY KEY,
+    file_path TEXT NOT NULL,
+    file_type TEXT,
+    content TEXT,
+    metadata TEXT, -- JSON
+    success_rate REAL DEFAULT 0.0,
+    usage_count INTEGER DEFAULT 0,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS pattern_similarities (
+    pattern1_id TEXT,
+    pattern2_id TEXT,
+    similarity REAL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (pattern1_id, pattern2_id)
+);
+
+-- Index for fast lookup
+CREATE INDEX IF NOT EXISTS idx_patterns_type ON patterns(file_type);
+CREATE INDEX IF NOT EXISTS idx_patterns_success_rate ON patterns(success_rate DESC);
+CREATE INDEX IF NOT EXISTS idx_patterns_usage ON patterns(usage_count DESC);
+```
+
+### 3. Search Algorithm
+
+```python
+# search_engine.py
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+
+class LocalSearchEngine:
+    def __init__(self, embeddings_manager, sqlite_db):
+        self.embeddings = embeddings_manager
+        self.db = sqlite_db
+
+    def search(self, query_pattern: str, file_type: str = None, limit: int = 10) -> List[Dict]:
+        """Search for similar patterns"""
+        # 1. Get query embedding
+        if query_pattern in embeddings_cache:
+            query_embedding = embeddings_cache[query_pattern]
+        else:
+            query_embedding = self.get_embedding(query_pattern)
+            embeddings_cache[query_pattern] = query_embedding
+
+        # 2. Get all candidate patterns
+        candidates = self.db.query("""
+            SELECT id, file_path, content, metadata, success_rate
+            FROM patterns
+            WHERE (? IS NULL OR file_type = ? OR file_type IS NULL)
+            ORDER BY usage_count DESC, success_rate DESC
+            LIMIT 100
+        """, (file_type, file_type))
+
+        # 3. Calculate similarities
+        embeddings_list = []
+        pattern_ids = []
+
+        for pattern in candidates:
+            embedding = self.embeddings.get_embedding(pattern[0])
+            if embedding is not None:
+                embeddings_list.append(embedding)
+                pattern_ids.append(pattern[0])
+
+        similarities = cosine_similarity([query_embedding], embeddings_list)[0]
+
+        # 4. Return top matches
+        results = []
+        for i, pattern_id in enumerate(pattern_ids[:limit]):
+            if similarities[i] > 0.7:  # Only return good matches
+                pattern_data = [p for p in candidates if p[0] == pattern_id][0]
+                results.append({
+                    'id': pattern_data[0],
+                    'content': pattern_data[2],
+                    'metadata': json.loads(pattern_data[3]),
+                    'success_rate': pattern_data[4],
+                    'usage_count': pattern_data[5],
+                    'similarity': float(similarities[i])
+                })
+
+        return sorted(results, key=lambda x: x['similarity'], reverse=True)
+```
+
+### 4. Auto-Sync with Remote (Optional)
+```bash
+# sync-with-remote.sh
+#!/bin/bash
+
+# Sync high-value patterns to remote RuVector for backup/syncronization
+sync_high_value_patterns() {
+    echo "Syncing high-value patterns to remote..."
+
+    # Query successful patterns with high usage
+    patterns=$(sqlite3 ~/.local-ruvector/cache.db "
+        SELECT id, content, metadata, usage_count, success_rate
+        FROM patterns
+        WHERE success_rate > 0.9
+          AND usage_count > 5
+        AND created_at > datetime('now', '-30 days')
+    ")
+
+    echo "$patterns" | while read -r line; do
+        id=$(echo "$line" | cut -d'|' -f1)
+        content=$(echo "$line" | cut -d'|' -f3)
+        metadata=$(echo "$line" | cut -d'|' -f4)
+
+        # Upload to remote (curl to your GitHub/ruvector)
+        curl -s -X POST "$RUVECTOR_REMOTE_URL/api/patterns" \
+            -H "Authorization: Bearer $RUVECTOR_TOKEN" \
+            -H "Content-Type: application/json" \
+            -d "{
+                \"id\": \"$id\",
+                \"content\": \"$content\",
+                \"metadata\": $metadata,
+                \"source\": \"local-sync\",
+                \"priority\": \"high\"
+            }"
+    done
+}
+```
+
+## Usage Examples
+
+### 1. Index Your Codebase
+```bash
+# Index a Rust project
+./index-code.sh --path ~/projects/my-rust-app
+
+# Index with specific patterns
+./index-code.sh --path ~/projects/python-dashboard --patterns "error-handling,authentication,testing"
+```
+
+### 2. Query Patterns Instantly
+```bash
+# Find authentication patterns
+./query-local.sh --pattern "authentication middleware" --file-type rust
+
+# Get best patterns for a specific error
+./query-local.sh --error "cannot borrow" --file-type rust --min-success 0.9
+
+# Search across all your projects
+./query-local.sh --path ~/projects/ --pattern "database migration"
+```
+
+### 3. Agent Integration
+```bash
+# Agent queries local patterns first (instant)
+./coordinate-generation.sh \
+  --agent-id "dev-$(date +%s)" \
+  --pattern "rust error handling" \
+  --source local \
+  --file-path "src/error.rs"
+
+# Fallback to remote if no local matches found
+```
+
+### 4. Learning Analytics
+```bash
+# See what patterns work best for you
+./analytics-local.sh --stats-by-type
+
+# Find your most successful patterns
+./analytics-local.sh --top-patterns --min-usage 10
+```
+
+## Performance Characteristics
+
+| Metric | Local Storage | PostgreSQL |
+|--------|---------------|-----------|
+| **Query Speed** | ~10-50ms | ~100-500ms |
+| **Setup Time** | < 1 minute | 10-15 minutes |
+| **Storage Size** | Scales with your disk | Limited by DB size |
+| **Network Dependency** | None | Required |
+| **Privacy** | 100% local | Depends on setup |
+| **Setup Complexity** | Low | Medium |
+
+## Optimization Features
+
+### 1. Smart Caching
+```bash
+# Cache frequently queried patterns
+# Automatically updated based on usage
+--cache-high-usage-threshold=10
+--cache-success-threshold=0.9
+```
+
+### 2. Pre-computed Similarities
+```bash
+# Pre-compute similarities for fast lookups
+--precompute-similarities
+--similarity-threshold=0.7
+```
+
+### 3. Hot Pattern Tracking
+```bash
+# Track patterns you use most often
+--track-usage-stats
+--auto-boost-patterns
+```
+
+## Benefits
+
+✅ **Speed**: Instant pattern lookup, no network latency
+✅ **Privacy**: All data stays local
+✅ **Reliability**: No external dependencies
+✅ **Control**: You manage what gets stored
+✅ **Offline**: Works without internet
+✅ **Portable**: Move between projects easily
+
+This gives you the pattern-learning benefits of RuVector with zero setup overhead and maximum speed for your personal development workflow!

package/.claude/skills/cfn-local-ruvector-accelerator/analyze-agent-failures.sh

@@ -0,0 +1,275 @@
+#!/bin/bash
+# analyze-agent-failures.sh - Analyze agent failures and extract reusable patterns
+#
+# Purpose: Query failed agents from the lifecycle database, extract error patterns,
+#          cluster similar failures, and store recovery strategies for future lookup.
+#
+# Usage:
+#   ./analyze-agent-failures.sh [--days N] [--min-occurrences N]
+#
+# Examples:
+#   ./analyze-agent-failures.sh --days 7
+#   ./analyze-agent-failures.sh --days 30 --min-occurrences 3
+
+set -euo pipefail
+
+# ============================================================================
+# Configuration
+# ============================================================================
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || echo ".")
+DB_PATH="${PROJECT_ROOT}/.claude/skills/cfn-redis-coordination/data/cfn-loop.db"
+LOG_PATH="${PROJECT_ROOT}/.artifacts/logs/ruvector-failure-analysis.log"
+
+# Ensure log directory exists
+mkdir -p "$(dirname "$LOG_PATH")"
+
+# ============================================================================
+# Parse Arguments
+# ============================================================================
+
+DAYS=7
+MIN_OCCURRENCES=2
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --days)
+            DAYS="$2"
+            shift 2
+            ;;
+        --min-occurrences)
+            MIN_OCCURRENCES="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown option: $1"
+            echo "Usage: $0 [--days N] [--min-occurrences N]"
+            exit 1
+            ;;
+    esac
+done
+
+echo "[RuVector] Analyzing agent failures from last $DAYS days" | tee -a "$LOG_PATH"
+
+# ============================================================================
+# Query Failed Agents
+# ============================================================================
+
+# Extract agents with failures or low confidence
+FAILED_AGENTS=$(sqlite3 "$DB_PATH" <<EOF
+SELECT
+    id,
+    type,
+    confidence,
+    metadata
+FROM agents
+WHERE
+    (status = 'completed' AND (confidence < 0.70 OR metadata LIKE '%"success": false%'))
+    OR status = 'failed'
+    AND datetime(completed_at) >= datetime('now', '-$DAYS days')
+ORDER BY completed_at DESC;
+EOF
+)
+
+if [ -z "$FAILED_AGENTS" ]; then
+    echo "[RuVector] No failures found in last $DAYS days" | tee -a "$LOG_PATH"
+    exit 0
+fi
+
+FAILURE_COUNT=$(echo "$FAILED_AGENTS" | wc -l)
+echo "[RuVector] Found $FAILURE_COUNT failed agent executions" | tee -a "$LOG_PATH"
+
+# ============================================================================
+# Extract Failure Patterns
+# ============================================================================
+
+# Parse each failed agent and extract:
+# 1. Failure mode (from transcript errors)
+# 2. Root cause (tool, validation, timeout, etc.)
+# 3. Recovery strategy (if any subsequent success)
+
+PATTERNS_CREATED=0
+
+echo "$FAILED_AGENTS" | while IFS='|' read -r AGENT_ID AGENT_TYPE CONFIDENCE METADATA; do
+
+    # Skip empty rows
+    [ -z "$AGENT_ID" ] && continue
+
+    # Extract failure context from metadata
+    TRANSCRIPT_PATH=$(echo "$METADATA" | grep -o '"transcript_path":"[^"]*"' | cut -d'"' -f4 || echo "")
+
+    if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
+        # Extract error snippets from transcript
+        ERROR_LINES=$(grep -i "error\|failed\|timeout\|validation" "$TRANSCRIPT_PATH" 2>/dev/null || echo "")
+
+        if [ -n "$ERROR_LINES" ]; then
+            # Classify failure mode
+            FAILURE_MODE="unknown"
+
+            if echo "$ERROR_LINES" | grep -q "pre-edit\|post-edit"; then
+                FAILURE_MODE="edit_hook_validation"
+            elif echo "$ERROR_LINES" | grep -q "timeout"; then
+                FAILURE_MODE="timeout"
+            elif echo "$ERROR_LINES" | grep -q "permission\|access"; then
+                FAILURE_MODE="permission_error"
+            elif echo "$ERROR_LINES" | grep -q "syntax\|parse"; then
+                FAILURE_MODE="syntax_error"
+            elif echo "$ERROR_LINES" | grep -q "test.*fail\|assertion"; then
+                FAILURE_MODE="test_failure"
+            fi
+
+            # Extract root cause (first error line, truncated)
+            ROOT_CAUSE=$(echo "$ERROR_LINES" | head -n 1 | head -c 200)
+
+            # Generate pattern ID
+            PATTERN_ID="failure-${AGENT_TYPE}-${FAILURE_MODE}-$(date +%s)"
+
+            # Check if similar pattern already exists
+            EXISTING_PATTERN=$(sqlite3 "$DB_PATH" <<SQL_EOF
+SELECT id, occurrence_count
+FROM agent_failure_patterns
+WHERE agent_type = '$AGENT_TYPE' AND failure_mode = '$FAILURE_MODE'
+ORDER BY last_seen DESC
+LIMIT 1;
+SQL_EOF
+)
+
+            if [ -n "$EXISTING_PATTERN" ]; then
+                # Update existing pattern
+                EXISTING_ID=$(echo "$EXISTING_PATTERN" | cut -d'|' -f1)
+                EXISTING_COUNT=$(echo "$EXISTING_PATTERN" | cut -d'|' -f2)
+                NEW_COUNT=$((EXISTING_COUNT + 1))
+
+                sqlite3 "$DB_PATH" <<SQL_EOF
+UPDATE agent_failure_patterns
+SET
+    occurrence_count = $NEW_COUNT,
+    last_seen = datetime('now'),
+    root_cause = '$ROOT_CAUSE'
+WHERE id = '$EXISTING_ID';
+SQL_EOF
+
+                echo "[RuVector] Updated pattern: $EXISTING_ID (count: $NEW_COUNT)" | tee -a "$LOG_PATH"
+
+            else
+                # Create new pattern
+                METADATA_JSON=$(cat <<JSON_EOF
+{
+    "first_agent_id": "$AGENT_ID",
+    "confidence": $CONFIDENCE,
+    "discovered": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+}
+JSON_EOF
+)
+
+                sqlite3 "$DB_PATH" <<SQL_EOF
+INSERT INTO agent_failure_patterns
+(id, agent_type, failure_mode, root_cause, metadata, last_seen)
+VALUES (
+    '$PATTERN_ID',
+    '$AGENT_TYPE',
+    '$FAILURE_MODE',
+    '$ROOT_CAUSE',
+    '$METADATA_JSON',
+    datetime('now')
+);
+SQL_EOF
+
+                PATTERNS_CREATED=$((PATTERNS_CREATED + 1))
+                echo "[RuVector] Created pattern: $PATTERN_ID ($AGENT_TYPE / $FAILURE_MODE)" | tee -a "$LOG_PATH"
+            fi
+        fi
+    fi
+done
+
+echo "[RuVector] Created $PATTERNS_CREATED new failure patterns" | tee -a "$LOG_PATH"
+
+# ============================================================================
+# Identify High-Impact Patterns
+# ============================================================================
+
+# Query patterns that occur frequently (>= MIN_OCCURRENCES)
+HIGH_IMPACT=$(sqlite3 "$DB_PATH" <<EOF
+SELECT
+    agent_type,
+    failure_mode,
+    occurrence_count,
+    root_cause
+FROM agent_failure_patterns
+WHERE occurrence_count >= $MIN_OCCURRENCES
+ORDER BY occurrence_count DESC
+LIMIT 10;
+EOF
+)
+
+if [ -n "$HIGH_IMPACT" ]; then
+    echo "" | tee -a "$LOG_PATH"
+    echo "[RuVector] High-impact failure patterns (>= $MIN_OCCURRENCES occurrences):" | tee -a "$LOG_PATH"
+    echo "$HIGH_IMPACT" | while IFS='|' read -r TYPE MODE COUNT CAUSE; do
+        echo "  - $TYPE / $MODE: $COUNT occurrences" | tee -a "$LOG_PATH"
+        echo "    Cause: $(echo "$CAUSE" | head -c 80)..." | tee -a "$LOG_PATH"
+    done
+fi
+
+# ============================================================================
+# Generate Recovery Recommendations
+# ============================================================================
+
+# For patterns with multiple occurrences, check if any similar agents succeeded
+# and extract their approaches as recovery strategies
+
+echo "" | tee -a "$LOG_PATH"
+echo "[RuVector] Searching for recovery strategies..." | tee -a "$LOG_PATH"
+
+RECOVERIES_FOUND=0
+
+sqlite3 "$DB_PATH" "SELECT DISTINCT agent_type, failure_mode FROM agent_failure_patterns WHERE occurrence_count >= 2;" | \
+while IFS='|' read -r TYPE MODE; do
+
+    # Find successful agents of same type after failures
+    SUCCESSFUL=$(sqlite3 "$DB_PATH" <<SQL_EOF
+SELECT id, metadata
+FROM agents
+WHERE
+    type = '$TYPE'
+    AND status = 'completed'
+    AND confidence >= 0.80
+    AND datetime(completed_at) >= datetime('now', '-$DAYS days')
+ORDER BY completed_at DESC
+LIMIT 5;
+SQL_EOF
+)
+
+    if [ -n "$SUCCESSFUL" ]; then
+        # Extract common patterns from successful executions
+        RECOVERY_STRATEGY="Successful $TYPE agents: used similar tool chains with validation steps"
+
+        # Update failure pattern with recovery strategy
+        sqlite3 "$DB_PATH" <<SQL_EOF
+UPDATE agent_failure_patterns
+SET
+    recovery_strategy = '$RECOVERY_STRATEGY',
+    resolution_rate = 0.50
+WHERE agent_type = '$TYPE' AND failure_mode = '$MODE';
+SQL_EOF
+
+        RECOVERIES_FOUND=$((RECOVERIES_FOUND + 1))
+        echo "  - Found recovery for: $TYPE / $MODE" | tee -a "$LOG_PATH"
+    fi
+done
+
+echo "[RuVector] Identified $RECOVERIES_FOUND recovery strategies" | tee -a "$LOG_PATH"
+
+# ============================================================================
+# Summary Report
+# ============================================================================
+
+echo "" | tee -a "$LOG_PATH"
+echo "[RuVector] Failure Analysis Summary:" | tee -a "$LOG_PATH"
+echo "  - Analyzed: $FAILURE_COUNT failed agents" | tee -a "$LOG_PATH"
+echo "  - New patterns: $PATTERNS_CREATED" | tee -a "$LOG_PATH"
+echo "  - Recovery strategies: $RECOVERIES_FOUND" | tee -a "$LOG_PATH"
+echo "" | tee -a "$LOG_PATH"
+
+exit 0