claude-flow-novice 2.18.38 → 2.18.39

package/.claude/skills/cfn-local-ruvector-accelerator/.claude/hooks/SessionStart-cfn-build-ruvector.sh

@@ -1,12 +1,13 @@
 #!/bin/bash
-# SessionStart hook: Build RuVector Rust binary if missing
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-RUVECTOR_DIR="$PROJECT_ROOT/.claude/skills/cfn-local-ruvector-accelerator"
-BINARY="$RUVECTOR_DIR/target/release/local-ruvector"
+# SessionStart hook: Verify RuVector binary is available
+BINARY="$HOME/.local/bin/local-ruvector"
 
-if [ ! -f "$BINARY" ]; then
-    echo "[cfn-build-ruvector] Building RuVector..."
-    command -v cargo &>/dev/null && cd "$RUVECTOR_DIR" && cargo build --release --quiet 2>/dev/null
-    [ -f "$BINARY" ] && echo "[cfn-build-ruvector] ✅ Built" || echo "[cfn-build-ruvector] Build skipped"
+# Check if binary exists in PATH or ~/.local/bin
+if command -v local-ruvector &>/dev/null; then
+    echo "[cfn-build-ruvector] ✅ local-ruvector available in PATH"
+elif [ -x "$BINARY" ]; then
+    echo "[cfn-build-ruvector] ✅ local-ruvector available at $BINARY"
+else
+    echo "[cfn-build-ruvector] ⚠️  local-ruvector not found"
+    echo "[cfn-build-ruvector] Install with: ./scripts/install-ruvector-global.sh"
 fi

package/.claude/skills/cfn-local-ruvector-accelerator/index-code.sh

@@ -1,25 +1,17 @@
 #!/bin/bash
-# index-code.sh - Index codebase patterns for local RuVector with security controls
+# index-code.sh - Index codebase using local-ruvector Rust binary
+# This is a wrapper around the Rust binary for convenience
 
 set -e
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-STORAGE_PATH="${HOME}/.local-ruvector"
-DEFAULT_PATH="."
 
-# Security configuration
-MAX_FILES_TO_PROCESS=10000
-MAX_DEPTH=10
-SUSPICIOUS_PATTERNS=("node_modules" ".git" "/dist/" "/build/" "/target/" ".svn" ".hg" "__pycache__" ".pytest_cache")
-
-# Parse arguments
-PATH_TO_INDEX=""
-FILE_TYPES=("")
-PATTERNS=""
-VERBOSE=false
+# Default values
+PATH_TO_INDEX="."
+FILE_TYPES="ts,tsx,js,jsx,py,sh,sql,rs"
 HELP=false
-MAX_FILES=${MAX_FILES_TO_PROCESS}
 
+# Parse arguments
 while [[ $# -gt 0 ]]; do
     case $1 in
         --path)
@@ -27,27 +19,15 @@ while [[ $# -gt 0 ]]; do
             shift 2
             ;;
         --types)
-            IFS=',' read -ra FILE_TYPES <<< "$2"
-            shift 2
-            ;;
-        --patterns)
-            PATTERNS="$2"
+            FILE_TYPES="$2"
             shift 2
             ;;
-        --max-files)
-            MAX_FILES="$2"
-            shift 2
-            ;;
-        --verbose)
-            VERBOSE=true
-            shift
-            ;;
         --help|-h)
             HELP=true
             shift
             ;;
         *)
-            if [[ -z "$PATH_TO_INDEX" ]]; then
+            if [[ -z "$PATH_TO_INDEX" || "$PATH_TO_INDEX" == "." ]]; then
                 PATH_TO_INDEX="$1"
             fi
             shift
@@ -55,391 +35,57 @@ while [[ $# -gt 0 ]]; do
     esac
 done
 
-# Security validation functions
-validate_path() {
-    local path="$1"
-
-    # Reject null bytes and control characters
-    if [[ "$path" =~ $'\0' ]]; then
-        echo "❌ Error: Path contains null bytes" >&2
-        exit 1
-    fi
-
-    # Reject absolute paths that aren't under the base
-    if [[ "$path" == /* && "$path" != "$PATH_TO_INDEX"/* ]]; then
-        echo "❌ Error: Absolute path outside base directory: $path" >&2
-        exit 1
-    fi
-
-    # Reject suspicious patterns
-    for pattern in "${SUSPICIOUS_PATTERNS[@]}"; do
-        if [[ "$path" == *"$pattern"* ]]; then
-            echo "❌ Error: Path contains suspicious pattern '$pattern': $path" >&2
-            exit 1
-        fi
-    done
-
-    # Reject paths with too many ..
-    if [[ $(echo "$path" | grep -o '\.\.' | wc -l) -gt 5 ]]; then
-        echo "❌ Error: Too many parent directory references: $path" >&2
-        exit 1
-    fi
-}
-
-validate_file_type() {
-    local ft="$1"
-
-    # Only allow alphanumeric and common extensions
-    if [[ ! "$ft" =~ ^[a-zA-Z0-9._-]+$ ]]; then
-        echo "❌ Error: Invalid file type format: $ft" >&2
-        exit 1
-    fi
-}
-
 # Show help
 if [[ "$HELP" == true ]]; then
     cat << EOF
 Usage: index-code [OPTIONS] [PATH]
 
-Index codebase patterns for local RuVector search with security controls
+Index codebase patterns using local-ruvector Rust binary
 
 Arguments:
   PATH                    Path to directory to index (default: current directory)
 
 Options:
   --path PATH            Path to directory to index
-  --types TYPES          Comma-separated file types (default: rs,py,js,ts,go,java)
-  --patterns PATTERNS    Comma-separated patterns to focus on
-  --max-files N          Maximum files to process (default: 10000)
-  --verbose              Show detailed progress
+  --types TYPES          Comma-separated file types (default: ts,tsx,js,jsx,py,sh,sql,rs)
   --help, -h             Show this help
 
-Security Features:
-  - Path traversal protection
-  - File size limits (10MB per file)
-  - Maximum files limit
-  - Suspicious pattern detection
-  - Input sanitization
+Database Location:
+  ~/.local/share/ruvector/index_v2.db
 
 Examples:
-  index-code --path ~/projects/my-rust-app
-  index-code --types rs,py --patterns "error-handling,authentication"
-  index-code --max-files 5000 --verbose
+  index-code --path ~/projects/my-app
+  index-code --types rs,py --path /path/to/project
 
 EOF
     exit 0
 fi
 
-# Set defaults
-if [[ -z "$PATH_TO_INDEX" ]]; then
-    PATH_TO_INDEX="$DEFAULT_PATH"
-fi
-
-if [[ ${#FILE_TYPES[@]} -eq 0 ]]; then
-    FILE_TYPES=("rs" "py" "js" "ts" "go" "java" "tsx" "jsx" "cpp" "c" "h" "cs" "php" "rb" "swift" "kt")
-fi
-
-# Validate max_files
-if ! [[ "$MAX_FILES" =~ ^[0-9]+$ ]] || [[ "$MAX_FILES" -lt 1 ]] || [[ "$MAX_FILES" -gt 100000 ]]; then
-    echo "❌ Error: Invalid max-files value: $MAX_FILES (must be 1-100000)" >&2
+# Find the binary
+if command -v local-ruvector &>/dev/null; then
+    BINARY="local-ruvector"
+elif [[ -x "$HOME/.local/bin/local-ruvector" ]]; then
+    BINARY="$HOME/.local/bin/local-ruvector"
+else
+    echo "❌ Error: local-ruvector binary not found"
+    echo "   Install with: ./scripts/install-ruvector-global.sh"
     exit 1
 fi
 
-# Validate path
-validate_path "$PATH_TO_INDEX"
-
-# Convert to absolute path and canonicalize
-PATH_TO_INDEX="$(cd "$PATH_TO_INDEX" && pwd -P)"
-
-# Additional security check - ensure we're not in a system directory
-if [[ "$PATH_TO_INDEX" == /etc/* ]] || [[ "$PATH_TO_INDEX" == /usr/bin/* ]] || [[ "$PATH_TO_INDEX" == /bin/* ]] || [[ "$PATH_TO_INDEX" == /sbin/* ]]; then
-    echo "❌ Error: Cannot index system directory: $PATH_TO_INDEX" >&2
+# Convert to absolute path
+PATH_TO_INDEX="$(cd "$PATH_TO_INDEX" 2>/dev/null && pwd)" || {
+    echo "❌ Error: Directory not found: $PATH_TO_INDEX"
     exit 1
-fi
-
-# Validate file types
-for ft in "${FILE_TYPES[@]}"; do
-    validate_file_type "$ft"
-done
-
-# Convert array to comma-separated string for Python
-FILE_TYPES_STR=$(IFS=','; echo "${FILE_TYPES[*]}")
+}
 
 echo "🔍 Indexing code patterns in: $PATH_TO_INDEX"
-echo "📄 File types: ${FILE_TYPES[*]}"
-echo "🔒 Security: Path traversal protection enabled"
-echo "📊 Maximum files: $MAX_FILES"
-if [[ -n "$PATTERNS" ]]; then
-    echo "🎯 Focusing on patterns: $PATTERNS"
-fi
-
-# Initialize search engine
-cd "$SCRIPT_DIR"
-python3 -c "
-import sys
-import os
-import json
-import hashlib
-import stat
-from pathlib import Path
-from search_engine_v2 import SearchEngine
-from security import SecurityError, PathValidator, ResourceMonitor, safe_file_read
-
-# Security checks
-def is_safe_file(file_path):
-    \"\"\"Check if file is safe to process\"\"\"
-    try:
-        # Check file permissions
-        file_stat = file_path.stat()
-
-        # Reject world-writable files
-        if file_stat.st_mode & stat.S_IWOTH:
-            return False, \"File is world-writable\"
-
-        # Reject files with suspicious permissions
-        if file_stat.st_mode & 0o7777 != 0o644 and file_stat.st_mode & 0o7777 != 0o755:
-            return False, f\"Suspicious file permissions: {oct(file_stat.st_mode & 0o7777)}\"
-
-        # Check if file is owned by current user (on Unix systems)
-        if hasattr(os, 'getuid') and file_stat.st_uid != os.getuid():
-            return False, \"File not owned by current user\"
-
-        return True, None
-
-    except Exception as e:
-        return False, f\"Error checking file: {e}\"
-
-def generate_pattern_id(file_path, content):
-    \"\"\"Generate unique pattern ID with security\"\"\"
-    # Use SHA-256 for better security
-    hash_input = f'{file_path}:{len(content)}:{hashlib.sha256(content.encode()).hexdigest()}'
-    hash_obj = hashlib.md5(hash_input.encode('utf-8'))
-    return f'pattern_{hash_obj.hexdigest()[:16]}'
-
-def extract_functions(content, file_type):
-    \"\"\"Extract functions/classes from code safely\"\"\"
-    patterns = []
-
-    # Limit content size for processing
-    if len(content) > 50000:
-        content = content[:50000]
-
-    # Simple extraction based on language
-    if file_type == 'rs':
-        import re
-        # Limit regex operations
-        lines = content.split('\\n')[:1000]  # Limit to first 1000 lines
-
-        fn_pattern = r'^(pub\\s+)?(async\\s+)?(unsafe\\s+)?fn\\s+(\\w+)'
-        struct_pattern = r'^(pub\\s+)?struct\\s+(\\w+)'
-        impl_pattern = r'^impl\\s+(\\w+)\\s*(for\\s+(\\w+))?'
-
-        for i, line in enumerate(lines):
-            for pattern, type_name in [(fn_pattern, 'function'),
-                                      (struct_pattern, 'struct'),
-                                      (impl_pattern, 'impl')]:
-                match = re.match(pattern, line)
-                if match:
-                    patterns.append({
-                        'type': type_name,
-                        'name': match.groups()[-1][:100],  # Limit name length
-                        'line': i + 1,
-                        'signature': line.strip()[:200]  # Limit signature length
-                    })
-
-    elif file_type == 'py':
-        import re
-        lines = content.split('\\n')[:1000]
-
-        fn_pattern = r'^\\s*def\\s+(\\w+)'
-        class_pattern = r'^\\s*class\\s+(\\w+)'
-
-        for i, line in enumerate(lines):
-            if re.match(fn_pattern, line):
-                patterns.append({
-                    'type': 'function',
-                    'name': re.match(fn_pattern, line).group(1)[:100],
-                    'line': i + 1,
-                    'signature': line.strip()[:200]
-                })
-            elif re.match(class_pattern, line):
-                patterns.append({
-                    'type': 'class',
-                    'name': re.match(class_pattern, line).group(1)[:100],
-                    'line': i + 1,
-                    'signature': line.strip()[:200]
-                })
-
-    return patterns[:50]  # Limit number of patterns per file
-
-# Initialize security
-try:
-    validator = PathValidator('${PATH_TO_INDEX}')
-    monitor = ResourceMonitor()
-
-    # Initialize engine with security
-    engine = SearchEngine('${STORAGE_PATH}/storage')
-
-    print('📂 Scanning files with security checks...')
-
-    # Parse file types from shell
-    file_types = '${FILE_TYPES_STR}'.split(',')
-    verbose = '${VERBOSE}' == 'true'
-    max_files = ${MAX_FILES}
-
-    # Index files with security
-    indexed_count = 0
-    pattern_count = 0
-    skipped_count = 0
-    error_count = 0
-
-    for file_type in file_types:
-        file_type = file_type.strip()
-        if not file_type:
-            continue
-
-        pattern = f'**/*.{file_type}'
-
-        # Use pathlib's rglob with depth limit
-        try:
-            files = list(Path('${PATH_TO_INDEX}').rglob(pattern))
-        except Exception as e:
-            print(f'⚠️  Error scanning for {file_type} files: {e}')
-            continue
-
-        # Limit total files
-        if indexed_count >= max_files:
-            print(f'⚠️  Reached maximum file limit ({max_files}), stopping')
-            break
-
-        for file_path in files:
-            # Check file limit
-            if indexed_count >= max_files:
-                break
-
-            if file_path.is_file():
-                try:
-                    # Validate path
-                    safe_path = validator.validate_path(file_path)
-
-                    # Additional safety checks
-                    is_safe, reason = is_safe_file(safe_path)
-                    if not is_safe:
-                        if verbose:
-                            print(f'  ⚠️  Skipped {file_path}: {reason}')
-                        skipped_count += 1
-                        continue
-
-                    # Check file size before reading
-                    monitor.check_file_size(safe_path)
-
-                    # Safely read file
-                    content = safe_file_read(safe_path)
-
-                    # Skip very small files
-                    if len(content) < 50:
-                        continue
-
-                    # Limit content size
-                    if len(content) > 1000000:  # 1MB limit
-                        content = content[:1000000]
-                        if verbose:
-                            print(f'  ⚠️  Truncated large file: {file_path}')
-
-                    # Generate pattern ID
-                    pattern_id = generate_pattern_id(str(safe_path), content)
-
-                    # Extract functions/classes safely
-                    patterns = extract_functions(content, file_type)
-
-                    # Prepare metadata with security
-                    metadata = {
-                        'file_size': len(content),
-                        'line_count': len(content.split('\\n')),
-                        'patterns': patterns,
-                        'last_modified': safe_path.stat().st_mtime,
-                        'indexed_by': 'secure-index-code',
-                        'security_verified': True
-                    }
-
-                    # Store pattern with security
-                    success = engine.add_pattern(
-                        pattern_id=pattern_id,
-                        file_path=str(safe_path),
-                        file_type=file_type,
-                        content=content,
-                        metadata=metadata
-                    )
-
-                    if success:
-                        indexed_count += 1
-                        pattern_count += len(patterns)
-                        monitor.record_file_processed(len(content))
-
-                        if verbose and indexed_count % 100 == 0:
-                            stats = monitor.get_stats()
-                            print(f'  📊 Processed {indexed_count} files, {stats[\"bytes_processed\"]:,} bytes')
-                    else:
-                        error_count += 1
-
-                except SecurityError as e:
-                    if verbose:
-                        print(f'  🔒 Security violation: {file_path} - {e}')
-                    skipped_count += 1
-                    continue
-                except Exception as e:
-                    if verbose:
-                        print(f'  ⚠️  Skipped {file_path}: {e}')
-                    error_count += 1
-                    continue
-
-    print(f'\\n🎉 Indexing completed with security controls!')
-    print(f'   ✅ Successfully indexed: {indexed_count} files')
-    print(f'   📋 Total patterns: {pattern_count}')
-    print(f'   ⚠️  Skipped files: {skipped_count}')
-    print(f'   ❌ Errors: {error_count}')
-    print(f'   📍 Storage: ${STORAGE_PATH}')
-
-    # Show resource usage
-    stats = monitor.get_stats()
-    print(f'\\n📊 Resource Usage:')
-    print(f'   Files processed: {stats[\"files_processed\"]:,}')
-    print(f'   Bytes processed: {stats[\"bytes_processed\"]:,}')
-    print(f'   Processing time: {stats[\"elapsed_seconds\"]:.2f}s')
-    print(f'   Throughput: {stats[\"bytes_per_second\"]:,.0f} bytes/s')
-
-    # Show stats
-    stats = engine.get_stats()
-    print(f'\\n📈 Database Stats:')
-    print(f'   Total patterns: {stats[\"total_patterns\"]:,}')
-    print(f'   Average success rate: {stats[\"avg_success_rate\"]:.2f}')
-    print(f'   Total usage: {stats[\"total_usage\"]:,}')
-    print(f'   Unique file types: {stats[\"unique_file_types\"]}')
-    print(f'   Database size: {stats[\"database_size_bytes\"] / (1024*1024):.1f} MB')
-    print(f'   Total embeddings: {stats[\"total_embeddings\"]:,}')
-
-    # Security summary
-    print(f'\\n🔒 Security Summary:')
-    print(f'   ✅ Path traversal protection: Active')
-    print(f'   ✅ File size limits: Enforced')
-    print(f'   ✅ Input sanitization: Active')
-    print(f'   ✅ Permission checks: Active')
+echo "📄 File types: $FILE_TYPES"
+echo "🗄️  Database: ~/.local/share/ruvector/index_v2.db"
+echo ""
 
-except SecurityError as e:
-    print(f'\\n❌ Security error: {e}')
-    sys.exit(1)
-except Exception as e:
-    print(f'\\n❌ Unexpected error: {e}')
-    import traceback
-    traceback.print_exc()
-    sys.exit(1)
-"
+# Run the indexer
+$BINARY index --path "$PATH_TO_INDEX" --types "$FILE_TYPES"
 
 echo ""
-echo "✅ Indexing complete with security validation!"
-echo "🔒 Security features were applied during indexing"
-echo "💡 Query patterns with: query-local --pattern 'your search term'"
-echo "📊 View stats: query-local --stats"
-
-# Make script executable
-chmod +x "${BASH_SOURCE[0]}"
+echo "✅ Indexing complete!"
+echo "💡 Query patterns with: sqlite3 ~/.local/share/ruvector/index_v2.db \"SELECT * FROM entities WHERE name LIKE '%keyword%';\""

package/.claude/skills/cfn-local-ruvector-accelerator/index_all.sh

@@ -34,7 +34,7 @@ for ext in "${file_types[@]}"; do
     fi
 
     # Index this file type
-    ./target/release/local-ruvector index --path ../.. --types ${ext} --force
+    local-ruvector index --path ../.. --types ${ext} --force
 
     if [ $? -eq 0 ]; then
         echo "✅ Successfully indexed .${ext} files"

package/.claude/skills/cfn-local-ruvector-accelerator/init-local-ruvector.sh

@@ -1,112 +1,73 @@
 #!/bin/bash
-# init-local-ruvector.sh - One-command setup for local RuVector
+# init-local-ruvector.sh - Verify and setup local RuVector
+# Ensures the Rust binary is installed and PATH is configured
 
 set -e
 
-STORAGE_PATH="${HOME}/.local-ruvector"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BINARY_PATH="$HOME/.local/bin/local-ruvector"
+DB_PATH="$HOME/.local/share/ruvector/index_v2.db"
 
-echo "🚀 Initializing Local RuVector Accelerator..."
-
-# Create storage directory structure
-echo "📁 Creating storage structure at ${STORAGE_PATH}..."
-mkdir -p "${STORAGE_PATH}/storage"
-mkdir -p "${STORAGE_PATH}/indexes"
-mkdir -p "${STORAGE_PATH}/config"
-
-# Create default config
-echo "⚙️ Creating default configuration..."
-cat > "${STORAGE_PATH}/config/settings.json" << EOF
-{
-    "version": "1.0",
-    "embedding_dimension": 1536,
-    "similarity_threshold": 0.7,
-    "max_patterns_per_query": 100,
-    "cache_size": 1000,
-    "auto_cleanup": {
-        "enabled": true,
-        "days_old": 30,
-        "min_usage": 5
-    }
-}
-EOF
+echo "🚀 Checking Local RuVector Installation..."
+echo ""
 
-# Initialize Python environment
-echo "🐍 Setting up Python environment..."
-if command -v python3 &> /dev/null; then
-    PYTHON="python3"
-elif command -v python &> /dev/null; then
-    PYTHON="python"
+# Check if binary exists in PATH
+if command -v local-ruvector &>/dev/null; then
+    BINARY_LOCATION=$(command -v local-ruvector)
+    VERSION=$(local-ruvector --version 2>/dev/null || echo "unknown")
+    echo "✅ local-ruvector found in PATH"
+    echo "   Location: $BINARY_LOCATION"
+    echo "   Version: $VERSION"
+elif [[ -x "$BINARY_PATH" ]]; then
+    VERSION=$($BINARY_PATH --version 2>/dev/null || echo "unknown")
+    echo "✅ local-ruvector found at $BINARY_PATH"
+    echo "   Version: $VERSION"
+    echo ""
+    echo "⚠️  Binary not in PATH. Add to your shell profile:"
+    echo "   export PATH=\"\$HOME/.local/bin:\$PATH\""
 else
-    echo "❌ Error: Python not found. Please install Python 3.7+"
+    echo "❌ local-ruvector binary not found"
+    echo ""
+    echo "📦 Installation options:"
+    echo ""
+    echo "   Option 1 - Use install script (if available):"
+    echo "   ./scripts/install-ruvector-global.sh"
+    echo ""
+    echo "   Option 2 - Build from source (requires Rust):"
+    echo "   cd $SCRIPT_DIR"
+    echo "   cargo build --release"
+    echo "   cp target/release/local-ruvector ~/.local/bin/"
+    echo ""
     exit 1
 fi
 
-# Install required Python packages
-echo "📦 Installing required packages..."
-${PYTHON} -m pip install --quiet numpy scikit-learn sqlite3 2>/dev/null || {
-    echo "⚠️ Installing required packages system-wide..."
-    ${PYTHON} -m pip install numpy scikit-learn
-}
-
-# Test imports
-echo "🧪 Testing dependencies..."
-${PYTHON} -c "
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
-import sqlite3
-print('✅ All dependencies imported successfully')
-" || {
-    echo "❌ Error: Failed to import required dependencies"
-    exit 1
-}
-
-# Create CLI links
-echo "🔗 Creating CLI commands..."
-chmod +x "${SCRIPT_DIR}/index-code.sh"
-chmod +x "${SCRIPT_DIR}/query-local.sh"
-
-# Create convenience symlinks
-BIN_DIR="${HOME}/.local/bin"
-mkdir -p "${BIN_DIR}"
-
-# Remove old symlinks if they exist
-rm -f "${BIN_DIR}/index-code" "${BIN_DIR}/query-local"
-
-# Create new symlinks
-ln -s "${SCRIPT_DIR}/index-code.sh" "${BIN_DIR}/index-code"
-ln -s "${SCRIPT_DIR}/query-local.sh" "${BIN_DIR}/query-local"
+echo ""
 
-# Check if BIN_DIR is in PATH
-if [[ ":$PATH:" != *":${BIN_DIR}:"* ]]; then
-    echo ""
-    echo "⚠️  Add ${BIN_DIR} to your PATH:"
-    echo "   export PATH=\"\$PATH:${BIN_DIR}\""
-    echo "   echo 'export PATH=\"\$PATH:${BIN_DIR}\"' >> ~/.bashrc"
+# Check database
+if [[ -f "$DB_PATH" ]]; then
+    DB_SIZE=$(du -h "$DB_PATH" | cut -f1)
+    ENTITY_COUNT=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM entities;" 2>/dev/null || echo "0")
+    PROJECT_COUNT=$(sqlite3 "$DB_PATH" "SELECT COUNT(DISTINCT project_root) FROM entities WHERE project_root != '';" 2>/dev/null || echo "0")
+
+    echo "✅ Database found"
+    echo "   Location: $DB_PATH"
+    echo "   Size: $DB_SIZE"
+    echo "   Entities: $ENTITY_COUNT"
+    echo "   Projects: $PROJECT_COUNT"
+else
+    echo "⚠️  No database found at $DB_PATH"
+    echo "   Index a project with: local-ruvector index --path /your/project"
 fi
 
-# Initialize the database
-echo "🗄️ Initializing database..."
-${PYTHON} -c "
-import sys
-sys.path.append('${SCRIPT_DIR}')
-from search_engine_v2 import SearchEngine
-engine = SearchEngine('${STORAGE_PATH}/storage')
-print('✅ Database initialized')
-"
-
 echo ""
-echo "🎉 Local RuVector Accelerator initialized successfully!"
+echo "📖 Quick Start:"
+echo "   # Index a project"
+echo "   local-ruvector index --path ~/projects/my-app --types ts,tsx,js,jsx,py"
 echo ""
-echo "📍 Storage location: ${STORAGE_PATH}"
-echo "📖 Quick start:"
-echo "   index-code --path /path/to/project"
-echo "   query-local --pattern 'authentication middleware'"
+echo "   # Query via SQL"
+echo "   sqlite3 $DB_PATH \"SELECT file_path, name FROM entities WHERE name LIKE '%auth%' LIMIT 10;\""
 echo ""
-echo "💡 For help:"
-echo "   index-code --help"
-echo "   query-local --help"
-EOF
-
-# Make script executable
-chmod +x "${BASH_SOURCE[0]}"
+echo "   # Semantic search"
+echo "   local-ruvector query \"authentication middleware\""
+echo ""
+echo "🎉 Local RuVector is ready!"

package/.claude/skills/cfn-local-ruvector-accelerator/query-local.sh

@@ -1,18 +1,17 @@
 #!/bin/bash
-# query-local.sh - Query local RuVector for patterns
+# query-local.sh - Query local RuVector for patterns using Rust binary
+# This is a wrapper around the Rust binary for convenience
 
 set -e
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-STORAGE_PATH="${HOME}/.local-ruvector"
+DB_PATH="$HOME/.local/share/ruvector/index_v2.db"
 
 # Parse arguments
 PATTERN=""
 FILE_TYPE=""
 LIMIT=10
-MIN_SIMILARITY=0.7
-SHOW_CONTENT=false
-JSON_OUTPUT=false
+KIND=""
 HELP=false
 
 while [[ $# -gt 0 ]]; do
@@ -25,22 +24,14 @@ while [[ $# -gt 0 ]]; do
             FILE_TYPE="$2"
             shift 2
             ;;
-        --limit)
-            LIMIT="$2"
+        --kind)
+            KIND="$2"
             shift 2
             ;;
-        --min-similarity)
-            MIN_SIMILARITY="$2"
+        --limit)
+            LIMIT="$2"
             shift 2
             ;;
-        --show-content)
-            SHOW_CONTENT=true
-            shift
-            ;;
-        --json)
-            JSON_OUTPUT=true
-            shift
-            ;;
         --help|-h)
             HELP=true
             shift
@@ -59,111 +50,78 @@ if [[ "$HELP" == true ]] || [[ -z "$PATTERN" ]]; then
     cat << EOF
 Usage: query-local [OPTIONS] PATTERN
 
-Query local RuVector for similar code patterns
+Query local RuVector database for code patterns
 
 Arguments:
-  PATTERN               Search pattern or description
+  PATTERN               Search pattern (entity name or partial match)
 
 Options:
-  --pattern PATTERN     Search pattern or description
-  --file-type TYPE      Filter by file type (rs, py, js, etc.)
+  --pattern PATTERN     Search pattern
+  --file-type TYPE      Filter by file extension (rs, py, js, etc.)
+  --kind KIND           Filter by entity kind (function, struct, class, etc.)
   --limit NUMBER        Maximum results (default: 10)
-  --min-similarity NUM  Minimum similarity threshold (default: 0.7)
-  --show-content        Show full content of matching patterns
-  --json                Output results in JSON format
   --help, -h           Show this help
 
+Database Location:
+  $DB_PATH
+
 Examples:
-  query-local "authentication middleware"
-  query-local --file-type rs "error handling"
-  query-local --limit 5 --show-content "database connection"
-  query-local --json "API endpoint"
+  query-local "MyFunction"
+  query-local --kind function "auth"
+  query-local --file-type rs --limit 20 "handler"
+
+Advanced SQL queries:
+  # Find all functions
+  sqlite3 $DB_PATH "SELECT file_path, name, line_number FROM entities WHERE kind = 'function' LIMIT 10;"
+
+  # Find by file path pattern
+  sqlite3 $DB_PATH "SELECT name, line_number FROM entities WHERE file_path LIKE '%auth%';"
+
+  # Count entities per project
+  sqlite3 $DB_PATH "SELECT project_root, COUNT(*) FROM entities GROUP BY project_root;"
 
 EOF
     exit 0
 fi
 
-# Check if storage exists
-if [[ ! -d "$STORAGE_PATH" ]]; then
-    echo "❌ Error: Local RuVector not initialized"
-    echo "   Run: init-local-ruvector"
+# Check if database exists
+if [[ ! -f "$DB_PATH" ]]; then
+    echo "❌ Error: RuVector database not found at $DB_PATH"
+    echo "   Run: local-ruvector index --path /your/project"
     exit 1
 fi
 
+# Build SQL query
+SQL="SELECT file_path, name, kind, line_number FROM entities WHERE name LIKE '%${PATTERN}%'"
+
+if [[ -n "$FILE_TYPE" ]]; then
+    SQL="$SQL AND file_path LIKE '%.${FILE_TYPE}'"
+fi
+
+if [[ -n "$KIND" ]]; then
+    SQL="$SQL AND kind = '${KIND}'"
+fi
+
+SQL="$SQL LIMIT ${LIMIT};"
+
+echo "🔍 Searching for: $PATTERN"
+[[ -n "$FILE_TYPE" ]] && echo "📄 File type filter: $FILE_TYPE"
+[[ -n "$KIND" ]] && echo "🏷️  Kind filter: $KIND"
+echo ""
+
 # Run query
-cd "$SCRIPT_DIR"
-python3 -c "
-import sys
-import json
-from search_engine_v2 import SearchEngine
-
-# Initialize engine
-engine = SearchEngine('${STORAGE_PATH}/storage')
-
-# Perform search
-results = engine.search(
-    query_pattern='${PATTERN}',
-    file_type='${FILE_TYPE}' if '${FILE_TYPE}' else None,
-    limit=${LIMIT},
-    min_similarity=${MIN_SIMILARITY}
-)
-
-if not results:
-    print('😔 No matching patterns found')
-    print(f'💡 Try adjusting the similarity threshold (current: ${MIN_SIMILARITY})')
-    sys.exit(0)
-
-# Format output
-if ${JSON_OUTPUT}:
-    output = []
-    for result in results:
-        output.append({
-            'id': result['id'],
-            'file_path': result['file_path'],
-            'file_type': result['file_type'],
-            'similarity': round(result['similarity'], 3),
-            'composite_score': round(result['composite_score'], 3),
-            'success_rate': result['success_rate'],
-            'usage_count': result['usage_count'],
-            'metadata': result['metadata'],
-            'content': result['content'] if ${SHOW_CONTENT} else None
-        })
-    print(json.dumps(output, indent=2))
-else:
-    print(f'🔍 Found {len(results)} patterns matching \"${PATTERN}\"')
-    print()
-    
-    for i, result in enumerate(results, 1):
-        print(f'{i}. {result[\"file_path\"]}')
-        print(f'   📄 Type: {result[\"file_type\"]}')
-        print(f'   🎯 Similarity: {result[\"similarity\"]:.3f}')
-        print(f'   ⭐ Score: {result[\"composite_score\"]:.3f}')
-        print(f'   ✅ Success Rate: {result[\"success_rate\"]:.2f}')
-        print(f'   📊 Usage: {result[\"usage_count\"]} times')
-        
-        # Show patterns from metadata
-        if result['metadata'] and 'patterns' in result['metadata']:
-            patterns = result['metadata']['patterns']
-            if patterns:
-                print(f'   🔧 Contains: {len(patterns)} items')
-                for pattern in patterns[:3]:  # Show first 3
-                    print(f'      - {pattern[\"type\"]}: {pattern[\"name\"]}')
-                if len(patterns) > 3:
-                    print(f'      ... and {len(patterns) - 3} more')
-        
-        # Show content if requested
-        if ${SHOW_CONTENT}:
-            print()
-            print('   📝 Content:')
-            # Show first 20 lines
-            lines = result['content'].split('\\n')
-            for line in lines[:20]:
-                print(f'      {line}')
-            if len(lines) > 20:
-                print(f'      ... ({len(lines) - 20} more lines)')
-        
-        print()
-"
-
-# Make script executable
-chmod +x "${BASH_SOURCE[0]}"
+RESULTS=$(sqlite3 -header -column "$DB_PATH" "$SQL" 2>/dev/null)
+
+if [[ -z "$RESULTS" ]]; then
+    echo "😔 No matching patterns found for '$PATTERN'"
+    echo ""
+    echo "💡 Tips:"
+    echo "   - Try a broader search term"
+    echo "   - Check if your project is indexed: sqlite3 $DB_PATH 'SELECT COUNT(*) FROM entities;'"
+    echo "   - Reindex if needed: local-ruvector index --path /your/project"
+else
+    echo "$RESULTS"
+    echo ""
+    COUNT=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM entities WHERE name LIKE '%${PATTERN}%';")
+    echo "📊 Total matches: $COUNT (showing up to $LIMIT)"
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow-novice",
-  "version": "2.18.38",
+  "version": "2.18.39",
   "description": "Claude Flow Novice - Advanced orchestration platform for multi-agent AI workflows with CFN Loop architecture\n\nIncludes Local RuVector Accelerator and all CFN skills for complete functionality.",
   "main": "index.js",
   "type": "module",