claude-flow-novice 2.18.12 → 2.18.14

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

@@ -0,0 +1,249 @@
+#!/bin/bash
+# index-code.sh - Index codebase patterns for local RuVector
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+STORAGE_PATH="${HOME}/.local-ruvector"
+DEFAULT_PATH="."
+
+# Parse arguments
+PATH_TO_INDEX=""
+FILE_TYPES=("")
+PATTERNS=""
+VERBOSE=false
+HELP=false
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --path)
+            PATH_TO_INDEX="$2"
+            shift 2
+            ;;
+        --types)
+            IFS=',' read -ra FILE_TYPES <<< "$2"
+            shift 2
+            ;;
+        --patterns)
+            PATTERNS="$2"
+            shift 2
+            ;;
+        --verbose)
+            VERBOSE=true
+            shift
+            ;;
+        --help|-h)
+            HELP=true
+            shift
+            ;;
+        *)
+            if [[ -z "$PATH_TO_INDEX" ]]; then
+                PATH_TO_INDEX="$1"
+            fi
+            shift
+            ;;
+    esac
+done
+
+# Show help
+if [[ "$HELP" == true ]]; then
+    cat << EOF
+Usage: index-code [OPTIONS] [PATH]
+
+Index codebase patterns for local RuVector search
+
+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
+  --verbose              Show detailed progress
+  --help, -h             Show this help
+
+Examples:
+  index-code --path ~/projects/my-rust-app
+  index-code --types rs,py --patterns "error-handling,authentication"
+  index-code --verbose
+
+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")
+fi
+
+# Validate path
+if [[ ! -d "$PATH_TO_INDEX" ]]; then
+    echo "❌ Error: Directory '$PATH_TO_INDEX' does not exist"
+    exit 1
+fi
+
+# Convert to absolute path
+PATH_TO_INDEX="$(cd "$PATH_TO_INDEX" && pwd)"
+
+# 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[*]}"
+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
+from pathlib import Path
+from search_engine_v2 import SearchEngine
+
+def generate_pattern_id(file_path, content):
+    \"\"\"Generate unique pattern ID\"\"\"
+    hash_obj = hashlib.md5(f'{file_path}:{content}'.encode())
+    return f'pattern_{hash_obj.hexdigest()[:16]}'
+
+def extract_functions(content, file_type):
+    \"\"\"Extract functions/classes from code\"\"\"
+    patterns = []
+
+    # Simple extraction based on language
+    if file_type == 'rs':
+        # Rust functions, structs, impls
+        import re
+        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(content.split('\\n')):
+            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],
+                        'line': i + 1,
+                        'signature': line.strip()
+                    })
+
+    elif file_type == 'py':
+        # Python functions, classes
+        import re
+        fn_pattern = r'^\s*def\s+(\w+)'
+        class_pattern = r'^\s*class\s+(\w+)'
+
+        for i, line in enumerate(content.split('\\n')):
+            if re.match(fn_pattern, line):
+                patterns.append({
+                    'type': 'function',
+                    'name': re.match(fn_pattern, line).group(1),
+                    'line': i + 1,
+                    'signature': line.strip()
+                })
+            elif re.match(class_pattern, line):
+                patterns.append({
+                    'type': 'class',
+                    'name': re.match(class_pattern, line).group(1),
+                    'line': i + 1,
+                    'signature': line.strip()
+                })
+
+    return patterns
+
+# Initialize engine
+engine = SearchEngine('${STORAGE_PATH}/storage')
+
+# Parse file types from shell
+file_types = '${FILE_TYPES_STR}'.split(',')
+verbose = '${VERBOSE}' == 'true'
+
+# Index files
+indexed_count = 0
+pattern_count = 0
+
+print('📂 Scanning files...')
+for file_type in file_types:
+    file_type = file_type.strip()
+    if not file_type:
+        continue
+    pattern = f'**/*.{file_type}'
+    files = list(Path('${PATH_TO_INDEX}').rglob(pattern))
+
+    for file_path in files:
+        # Skip node_modules, .git, dist, build directories
+        path_str = str(file_path)
+        if any(skip in path_str for skip in ['node_modules', '.git', '/dist/', '/build/', '/target/']):
+            continue
+
+        if file_path.is_file():
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+
+                if len(content) < 50:  # Skip very small files
+                    continue
+
+                # Generate pattern ID
+                pattern_id = generate_pattern_id(str(file_path), content)
+
+                # Extract functions/classes
+                patterns = extract_functions(content, file_type)
+
+                # Prepare metadata
+                metadata = {
+                    'file_size': len(content),
+                    'line_count': len(content.split('\\n')),
+                    'patterns': patterns,
+                    'last_modified': os.path.getmtime(file_path)
+                }
+
+                # Store pattern
+                engine.add_pattern(
+                    pattern_id=pattern_id,
+                    file_path=str(file_path),
+                    file_type=file_type,
+                    content=content,
+                    metadata=metadata
+                )
+
+                indexed_count += 1
+                pattern_count += len(patterns)
+
+                if verbose:
+                    print(f'  ✅ {file_path} ({len(patterns)} patterns)')
+
+            except Exception as e:
+                if verbose:
+                    print(f'  ⚠️  Skipped {file_path}: {e}')
+                continue
+
+print(f'\\n🎉 Indexed {indexed_count} files with {pattern_count} patterns')
+print(f'📍 Storage: ${STORAGE_PATH}')
+
+# Show stats
+stats = engine.get_stats()
+print(f'\\n📊 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'   File types: {stats[\"unique_file_types\"]}')
+"
+
+echo ""
+echo "✅ Indexing complete!"
+echo "💡 Query patterns with: query-local --pattern 'your search term'"
+
+# Make script executable
+chmod +x "${BASH_SOURCE[0]}"

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

@@ -0,0 +1,65 @@
+#!/bin/bash
+# Index all files in the project
+
+echo "Starting comprehensive indexing of all files..."
+cd .claude/skills/cfn-local-ruvector-accelerator
+
+# Clear existing index
+rm -rf index/
+
+# Define file extensions to index
+declare -a file_types=("rs" "py" "js" "ts" "tsx" "jsx" "go" "java" "json" "yaml" "yml" "md" "sh" "sql" "html" "css" "xml" "toml" "cfg" "ini" "conf" "txt")
+
+# Count total files
+total_files=0
+for ext in "${file_types[@]}"; do
+    count=$(find ../../ -type f -name "*.${ext}" 2>/dev/null | grep -v "/target/" | grep -v "/node_modules/" | grep -v "/.git/" | wc -l)
+    total_files=$((total_files + count))
+    echo "Found ${count} .${ext} files"
+done
+
+echo -e "\nTotal files to index: ${total_files}\n"
+
+# Index each file type
+start_time=$(date +%s)
+
+for ext in "${file_types[@]}"; do
+    echo -e "\n=== Indexing .${ext} files ==="
+
+    # Check if any files exist
+    file_list=$(find ../../ -type f -name "*.${ext}" 2>/dev/null | grep -v "/target/" | grep -v "/node_modules/" | grep -v "/.git/" | head -5)
+    if [ -z "$file_list" ]; then
+        echo "No .${ext} files found"
+        continue
+    fi
+
+    # Index this file type
+    ./target/release/local-ruvector index --path ../.. --types ${ext} --force
+
+    if [ $? -eq 0 ]; then
+        echo "✅ Successfully indexed .${ext} files"
+    else
+        echo "❌ Error indexing .${ext} files"
+    fi
+done
+
+end_time=$(date +%s)
+duration=$((end_time - start_time))
+
+echo -e "\n=== Indexing Complete ==="
+echo "Duration: ${duration} seconds"
+echo "Files indexed: ${total_files}"
+
+# Show index size
+if [ -d "index" ]; then
+    index_size=$(du -sh index | cut -f1)
+    echo "Index size: ${index_size}"
+fi
+
+# Show database stats
+if [ -f "index/index.db" ]; then
+    echo -e "\n=== Database Statistics ==="
+    sqlite3 index/index.db "SELECT 'entities: ' || COUNT(*) FROM entities;"
+    sqlite3 index/index.db "SELECT 'embeddings: ' || COUNT(*) FROM embeddings;"
+    sqlite3 index/index.db "SELECT 'references: ' || COUNT(*) FROM references;"
+fi

package/.claude/skills/cfn-local-ruvector-accelerator/src/cli/find.rs

@@ -0,0 +1,214 @@
+use anyhow::{Result, Context};
+use clap::Args;
+use serde_json::{json};
+use std::path::{Path, PathBuf};
+use tracing::{info, debug, warn};
+use serde::Serialize;
+
+use crate::query_api::{QueryApi, QueryResultFormatter};
+use crate::store_v2::{StoreV2};
+use crate::schema_v2::{EntityKind};
+
+#[derive(Debug, Args)]
+pub struct FindCommand {
+    /// Find functions using a specific type
+    #[arg(long)]
+    pub uses_type: Option<String>,
+
+    /// Find callers of a specific function
+    #[arg(long)]
+    pub called_by: Option<String>,
+
+    /// Find types from a file used elsewhere
+    #[arg(long)]
+    pub types_from: Option<String>,
+
+    /// Find implementations of a trait/interface
+    #[arg(long)]
+    pub implements: Option<String>,
+
+    /// Find public API of a module
+    #[arg(long)]
+    pub public_api: Option<String>,
+
+    /// Find references to a path
+    #[arg(long)]
+    pub refs_to: Option<String>,
+
+    /// Entity kind filter (function, struct, enum, etc.)
+    #[arg(long)]
+    pub kind: Option<String>,
+
+    /// Exclude module from results (for --called-by)
+    #[arg(long)]
+    pub exclude: Option<String>,
+
+    /// Maximum number of results to return
+    #[arg(short, long, default_value = "50")]
+    pub limit: usize,
+
+    /// Output format
+    #[arg(long, value_enum, default_value = "simple")]
+    pub format: FindOutputFormat,
+
+    /// Show detailed context
+    #[arg(long)]
+    pub detailed: bool,
+
+    /// Output file (optional)
+    #[arg(long)]
+    pub output: Option<PathBuf>,
+}
+
+#[derive(Debug, Clone, clap::ValueEnum)]
+pub enum FindOutputFormat {
+    Simple,
+    Json,
+    Detailed,
+    Csv,
+}
+
+impl FindCommand {
+    pub fn execute(&self, project_dir: &Path) -> Result<()> {
+        // Initialize store and query API
+        let db_path = project_dir.join(".ruvector").join("index.db");
+        let store = StoreV2::new(&db_path)
+            .context("Failed to open database")?;
+        let query_api = QueryApi::new(store);
+
+        // Execute the appropriate query
+        let result = match &self.find_type() {
+            FindType::FunctionsUsingType(type_name) => {
+                query_api.find_functions_using_type(type_name)
+            }
+            FindType::CallersOfFunction { function_name, exclude_module } => {
+                query_api.find_callers_of_function(function_name, exclude_module.as_deref())
+            }
+            FindType::TypesUsedElsewhere(file_path) => {
+                query_api.find_types_used_elsewhere(file_path)
+            }
+            FindType::Implementations(trait_name) => {
+                query_api.find_implementations(trait_name)
+            }
+            FindType::PublicAPI(module_path) => {
+                query_api.find_public_api(module_path)
+            }
+            FindType::ReferencesToPath(path) => {
+                query_api.find_references_to_path(path)
+            }
+            FindType::None => {
+                return Err(anyhow::anyhow!("No find criteria specified. Use one of the find options."));
+            }
+        }?;
+
+        // Filter by kind if specified
+        let filtered_result = if let Some(kind_str) = &self.kind {
+            if let Some(kind) = EntityKind::from_str(kind_str) {
+                let filtered_items: Vec<_> = result.results.into_iter()
+                    .filter(|item| item.entity.kind == kind)
+                    .collect();
+
+                let count = filtered_items.len();
+                crate::query_api::QueryResult {
+                    query_type: result.query_type,
+                    results: filtered_items,
+                    total_count: count,
+                }
+            } else {
+                warn!("Invalid entity kind: {}", kind_str);
+                result
+            }
+        } else {
+            result
+        };
+
+        // Apply limit
+        let limited_result = crate::query_api::QueryResult {
+            query_type: filtered_result.query_type,
+            results: filtered_result.results.into_iter().take(self.limit).collect(),
+            total_count: filtered_result.total_count,
+        };
+
+        // Format and output results
+        let output = match self.format {
+            FindOutputFormat::Simple => limited_result.format_simple(),
+            FindOutputFormat::Json => limited_result.format_json()?,
+            FindOutputFormat::Detailed => limited_result.format_detailed(),
+            FindOutputFormat::Csv => self.format_csv(&limited_result)?,
+        };
+
+        // Write output
+        if let Some(output_path) = &self.output {
+            std::fs::write(output_path, output)
+                .context("Failed to write output file")?;
+            info!("Results written to: {}", output_path.display());
+        } else {
+            println!("{}", output);
+        }
+
+        // Show summary if we truncated results
+        if limited_result.total_count > self.limit {
+            eprintln!("\n⚠️  Showing {} of {} total results", self.limit, limited_result.total_count);
+        }
+
+        info!("Find command completed: {} results found", limited_result.total_count);
+        Ok(())
+    }
+
+    fn find_type(&self) -> FindType {
+        if let Some(type_name) = &self.uses_type {
+            FindType::FunctionsUsingType(type_name.clone())
+        } else if let Some(function_name) = &self.called_by {
+            FindType::CallersOfFunction {
+                function_name: function_name.clone(),
+                exclude_module: self.exclude.clone(),
+            }
+        } else if let Some(file_path) = &self.types_from {
+            FindType::TypesUsedElsewhere(file_path.clone())
+        } else if let Some(trait_name) = &self.implements {
+            FindType::Implementations(trait_name.clone())
+        } else if let Some(module_path) = &self.public_api {
+            FindType::PublicAPI(module_path.clone())
+        } else if let Some(path) = &self.refs_to {
+            FindType::ReferencesToPath(path.clone())
+        } else {
+            FindType::None
+        }
+    }
+
+    fn format_csv(&self, result: &crate::query_api::QueryResult) -> Result<String> {
+        let mut output = String::new();
+
+        // CSV header
+        output.push_str("file_path,line_number,kind,name,visibility,score\n");
+
+        // CSV rows
+        for item in &result.results {
+            output.push_str(&format!(
+                "{},{},{},{},{},{}\n",
+                item.entity.file_path,
+                item.entity.line_number,
+                item.entity.kind.as_str(),
+                item.entity.name,
+                item.entity.visibility.as_str(),
+                item.score
+            ));
+        }
+
+        Ok(output)
+    }
+}
+
+#[derive(Debug)]
+enum FindType {
+    FunctionsUsingType(String),
+    CallersOfFunction {
+        function_name: String,
+        exclude_module: Option<String>,
+    },
+    TypesUsedElsewhere(String),
+    Implementations(String),
+    PublicAPI(String),
+    ReferencesToPath(String),
+    None,
+}