claude-flow-novice 2.18.12 → 2.18.14

package/.claude/skills/cfn-local-ruvector-accelerator/.backups/unknown/1765358428_2cf0ad7377232c919ff0a65630cb307d/original

@@ -0,0 +1,209 @@
+use anyhow::{Result, Context};
+use clap::Args;
+use serde_json::{json};
+use std::path::{Path, PathBuf};
+use tracing::{info, debug, warn};
+
+use crate::query_api::{QueryApi, QueryResultFormatter};
+use crate::store_v2::{StoreV2};
+
+#[derive(Debug, Args)]
+pub struct RefsCommand {
+    /// Find all references to an entity by name
+    #[arg()]
+    pub entity_name: String,
+
+    /// Entity kind to search for (function, struct, enum, etc.)
+    #[arg(long)]
+    pub kind: Option<String>,
+
+    /// Reference kind filter (call, import, implement, etc.)
+    #[arg(long)]
+    pub ref_kind: Option<String>,
+
+    /// Limit search to specific file
+    #[arg(long)]
+    pub file: 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: RefsOutputFormat,
+
+    /// Show detailed context
+    #[arg(long)]
+    pub detailed: bool,
+
+    /// Output file (optional)
+    #[arg(long)]
+    pub output: Option<PathBuf>,
+
+    /// Group results by file
+    #[arg(long)]
+    pub group_by_file: bool,
+
+    /// Include only inbound references (references to this entity)
+    #[arg(long)]
+    pub inbound: bool,
+
+    /// Include only outbound references (references from this entity)
+    #[arg(long)]
+    pub outbound: bool,
+}
+
+#[derive(Debug, Clone, clap::ValueEnum)]
+pub enum RefsOutputFormat {
+    Simple,
+    Json,
+    Detailed,
+    Tree,
+}
+
+impl RefsCommand {
+    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);
+
+        // Build a path-like search term
+        let search_term = if let Some(kind) = &self.kind {
+            format!("{}::{}", kind, self.entity_name)
+        } else {
+            self.entity_name.clone()
+        };
+
+        // Find references using the query API
+        let mut result = query_api.find_references_to_path(&search_term)?;
+
+        // Filter results based on command options
+        let filtered_results: Vec<_> = result.results.into_iter()
+            .filter(|item| {
+                // Filter by file if specified
+                if let Some(file) = &self.file {
+                    if !item.entity.file_path.contains(file) {
+                        return false;
+                    }
+                }
+
+                // Additional filtering could be added here for ref_kind
+                true
+            })
+            .collect();
+
+        // Update the result with filtered items
+        result.results = filtered_results;
+        result.total_count = result.results.len();
+
+        // Apply limit
+        let limited_result = crate::query_api::QueryResult {
+            query_type: result.query_type,
+            results: result.results.into_iter().take(self.limit).collect(),
+            total_count: result.total_count,
+        };
+
+        // Format and output results
+        let output = match self.format {
+            RefsOutputFormat::Simple => self.format_simple(&limited_result),
+            RefsOutputFormat::Json => limited_result.format_json()?,
+            RefsOutputFormat::Detailed => limited_result.format_detailed(),
+            RefsOutputFormat::Tree => self.format_tree(&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!("Refs command completed: {} references found", limited_result.total_count);
+        Ok(())
+    }
+
+    fn format_simple(&self, result: &crate::query_api::QueryResult) -> String {
+        if self.group_by_file {
+            let mut groups = std::collections::HashMap::new();
+            for item in &result.results {
+                groups.entry(&item.entity.file_path)
+                    .or_insert_with(Vec::new)
+                    .push(item);
+            }
+
+            let mut output = String::new();
+            for (file_path, items) in groups {
+                output.push_str(&format!("\n📁 {}\n", file_path));
+                for item in items {
+                    output.push_str(&format!("  {}:{} - {}\n",
+                        item.entity.line_number,
+                        item.entity.name,
+                        item.entity.kind.as_str()
+                    ));
+                }
+            }
+            output.trim_start().to_string()
+        } else {
+            result.results.iter()
+                .map(|item| format!("{}:{} - {} ({})",
+                    item.entity.file_path,
+                    item.entity.line_number,
+                    item.entity.name,
+                    item.entity.kind.as_str()))
+                .collect::<Vec<_>>()
+                .join("\n")
+        }
+    }
+
+    fn format_tree(&self, result: &crate::query_api::QueryResult) -> String {
+        let mut tree = String::new();
+
+        // Group by file for tree view
+        let mut groups = std::collections::HashMap::new();
+        for item in &result.results {
+            groups.entry(&item.entity.file_path)
+                .or_insert_with(Vec::new)
+                .push(item);
+        }
+
+        for (file_path, items) in groups {
+            tree.push_str(&format!("📁 {}\n", file_path));
+
+            // Group by line number to show multiple refs on same line
+            let mut line_groups = std::collections::HashMap::new();
+            for item in items {
+                line_groups.entry(item.entity.line_number)
+                    .or_insert_with(Vec::new)
+                    .push(item);
+            }
+
+            for (line, items_at_line) in line_groups {
+                tree.push_str(&format!("  📍 Line {}:\n", line));
+                for item in items_at_line {
+                    tree.push_str(&format!("    ├── {} ({})\n",
+                        item.entity.name,
+                        item.entity.kind.as_str()
+                    ));
+                    if let Some(context) = &item.context {
+                        let first_line = context.lines().next().unwrap_or("").trim();
+                        if !first_line.is_empty() {
+                            tree.push_str(&format!("    │   └─ {}\n", first_line));
+                        }
+                    }
+                }
+            }
+        }
+
+        tree
+    }
+}

package/.claude/skills/cfn-local-ruvector-accelerator/.backups/unknown/1765358428_2cf0ad7377232c919ff0a65630cb307d/revert.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+# Revert script for /mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-local-ruvector-accelerator/src/cli/refs.rs
+set -euo pipefail
+
+echo "Reverting file: /mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-local-ruvector-accelerator/src/cli/refs.rs"
+cp "/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-local-ruvector-accelerator/.backups/unknown/1765358428_2cf0ad7377232c919ff0a65630cb307d/original" "/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-local-ruvector-accelerator/src/cli/refs.rs"
+echo "✅ File reverted successfully"

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

@@ -0,0 +1,255 @@
+# Agent Integration Patterns for AST-Aware RuVector
+
+This document describes how agents can integrate with the AST-aware RuVector indexer to achieve sub-50ms query performance for code intelligence tasks.
+
+## Overview
+
+The AST-Aware RuVector Accelerator provides:
+- Entity-based indexing (functions, structs, traits, etc.)
+- Reference tracking (calls, imports, type usage)
+- Vector embeddings for semantic search
+- Structured query interface
+
+## Integration Patterns
+
+### 1. Agent Setup
+
+```bash
+# Initialize RuVector in the project
+./target/release/local-ruvector init
+
+# Index the codebase
+./target/release/local-ruvector index --path . --types rs,ts,tsx,js,jsx --force
+```
+
+### 2. Query Patterns
+
+#### A. Find Functions Using a Type
+
+```bash
+# Find all functions that use the `Album` type
+./target/release/local-ruvector find --kind function --uses-type Album
+
+# Example SQL query behind the scenes:
+SELECT e.* FROM entities e
+JOIN type_usage tu ON e.id = tu.entity_id
+WHERE e.kind = 'function' AND tu.type_name = 'Album';
+```
+
+#### B. Find Callers of a Function
+
+```bash
+# Find all functions that call `create_album`
+./target/release/local-ruvector refs --target create_album --kind calls
+
+# Exclude calls within the same module
+./target/release/local-ruvector refs --target create_album --kind calls --exclude-module src/album/
+
+# Example SQL query:
+SELECT r.* FROM refs r
+JOIN entities e ON r.target_entity_id = e.id
+WHERE e.name = 'create_album' AND r.ref_kind = 'call'
+  AND r.file_path NOT LIKE '%src/album/%';
+```
+
+#### C. Refactoring Workflow
+
+```bash
+# Step 1: Find all references to a function
+./target/release/local-ruvector refs --target function_name
+
+# Step 2: Find all implementations of a trait
+./target/release/local-ruvector find --kind impl --implements Trait
+
+# Step 3: Find types used in a module
+./target/release/local-ruvector find --file-path src/module/ --kind struct
+
+# Step 4: Verify no breaks after refactoring
+./target/release/local-ruvector query "broken reference error" --threshold 0.9
+```
+
+### 3. Programmatic Integration
+
+Agents can integrate using the Rust API directly:
+
+```rust
+use local_ruvector::store_v2::StoreV2;
+use local_ruvector::query_api::QueryEngine;
+
+let store = StoreV2::new(&db_path)?;
+let query_engine = QueryEngine::new(store);
+
+// Find functions using a type
+let functions = query_engine.find_functions_using_type("Album")?;
+
+// Find callers of a function
+let callers = query_engine.find_callers("create_album", Some("src/other/"))?;
+
+// Search by semantic similarity
+let results = query_engine.semantic_search("database transaction", 10)?;
+```
+
+### 4. Performance Optimization Tips
+
+#### A. Use Database Indexes
+The schema includes optimized indexes:
+- `idx_entities_kind_name` for fast entity lookups
+- `idx_type_usage_type_name` for type usage queries
+- `idx_refs_target_kind` for reference queries
+
+#### B. Batch Operations
+```rust
+// Batch insert entities
+let entities: Vec<Entity> = vec![...];
+store.insert_entities_batch(entities)?;
+
+// Batch query multiple entities
+let ids = vec![1, 2, 3, 4, 5];
+let entities = store.get_entity_batch(&ids)?;
+```
+
+#### C. Query Result Caching
+```rust
+use std::time::Duration;
+use cached::proc_macro::cached;
+
+#[cached(size = 1000, time = 300)]
+pub fn find_functions_using_type(type_name: &str) -> Result<Vec<Entity>> {
+    // Query implementation
+}
+```
+
+## Agent Workflow Examples
+
+### 1. Code Review Agent
+
+```rust
+pub async fn review_pull_request(pr_id: i32) -> Result<ReviewResult> {
+    // 1. Get changed files
+    let changed_files = get_pr_files(pr_id).await?;
+
+    // 2. Query for potentially problematic patterns
+    let issues = query_engine.search_patterns([
+        "TODO:",
+        "FIXME:",
+        "unwrap()",
+        "panic!",
+        "expect(",
+    ])?;
+
+    // 3. Check for breaking changes
+    let public_api_changes = query_engine.find_public_api_changes(&changed_files)?;
+
+    // 4. Verify imports are correct
+    let unused_imports = query_engine.find_unused_imports(&changed_files)?;
+
+    Ok(ReviewResult { issues, public_api_changes, unused_imports })
+}
+```
+
+### 2. Refactoring Agent
+
+```rust
+pub async fn extract_function(
+    file_path: &str,
+    start_line: usize,
+    end_line: usize,
+    function_name: &str,
+) -> Result<RefactorResult> {
+    // 1. Analyze the selected code
+    let entities = query_engine.find_entities_in_range(file_path, start_line, end_line)?;
+
+    // 2. Find all external dependencies
+    let dependencies = query_engine.find_dependencies(&entities)?;
+
+    // 3. Check if extraction is safe
+    let safe_to_extract = query_engine.verify_extraction_safety(&entities)?;
+
+    if safe_to_extract {
+        // 4. Perform refactoring
+        let new_content = extract_function_to_module(file_path, start_line, end_line, function_name)?;
+
+        // 5. Update imports in dependent files
+        for dep in dependencies {
+            update_imports(&dep.file_path, function_name)?;
+        }
+
+        Ok(RefactorResult::Success)
+    } else {
+        Ok(RefactorResult::Unsafe)
+    }
+}
+```
+
+### 3. Documentation Agent
+
+```rust
+pub async fn generate_documentation(entity_name: &str) -> Result<Documentation> {
+    // 1. Find the entity
+    let entity = query_engine.find_entity_by_name(entity_name)?;
+
+    // 2. Get all related documentation
+    let related_docs = query_engine.find_related_documentation(&entity)?;
+
+    // 3. Find usage examples
+    let examples = query_engine.find_usage_examples(&entity)?;
+
+    // 4. Check for undocumented public APIs
+    if entity.visibility == Visibility::Public && entity.doc_comment.is_none() {
+        return Err(anyhow!("Public entity lacks documentation"));
+    }
+
+    // 5. Generate comprehensive docs
+    Ok(Documentation {
+        entity,
+        related_docs,
+        examples,
+    })
+}
+```
+
+## Performance Benchmarks
+
+Based on the current implementation:
+
+- **Index Size**: 175MB for 31 Rust files with 5,897 embeddings
+- **Index Time**: ~90 seconds for full reindex
+- **Query Performance**: Target <50ms for indexed queries
+- **Entity Coverage**: Functions, structs, traits, impls, enums
+
+## Future Enhancements
+
+1. **Incremental Updates**: Only reindex changed files
+2. **Cross-Language Support**: TypeScript, JavaScript support
+3. **Enhanced Query API**: More complex query builders
+4. **Integration with LLMs**: Use embeddings for AI-assisted coding
+5. **Real-time Updates**: File watching for automatic reindexing
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Compilation Errors**: Ensure tree-sitter parsers are properly linked
+2. **Database Locks**: Use WAL mode for concurrent access
+3. **Memory Usage**: Limit batch sizes for large codebases
+4. **Slow Queries**: Check EXPLAIN QUERY PLAN and add indexes
+
+### Debug Commands
+
+```bash
+# Check database health
+./target/release/local-ruvector stats --detailed
+
+# Rebuild index
+./target/release/local-ruvector index --force
+
+# Query optimization
+sqlite3 .ruvector/index.db "EXPLAIN QUERY PLAN SELECT ..."
+
+# Check embeddings
+./target/release/local-ruvector query "test query" --format json
+```
+
+## Conclusion
+
+The AST-Aware RuVector Accelerator provides a powerful foundation for agent-driven code intelligence. By leveraging entity-based indexing and structured queries, agents can achieve sub-50ms response times for complex code analysis tasks.

package/.claude/skills/cfn-local-ruvector-accelerator/Cargo.toml

@@ -37,4 +37,11 @@ chrono = { version = "0.4", features = ["serde"] }
 # File operations
 fs_extra = "1.3"
 # Environment
-dotenvy = "0.15"
+dotenvy = "0.15"
+# Tree-sitter for AST parsing
+# Tree-sitter for AST parsing
+
+# Tree-sitter for AST parsing
+tree-sitter = "0.20"
+tree-sitter-rust = "0.20"
+tree-sitter-typescript = "0.20"

package/.claude/skills/cfn-local-ruvector-accelerator/Cargo.toml.backup

@@ -0,0 +1,47 @@
+[package]
+name = "local-ruvector"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+# Database
+rusqlite = { version = "0.31", features = ["bundled", "vtab"] }
+# Vector operations
+ndarray = { version = "0.15", features = ["rayon"], default-features = false }
+# Serialization
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+# CLI
+clap = { version = "4.4", features = ["derive"] }
+anyhow = "1.0"
+# File system
+walkdir = "2.4"
+# Hashing
+sha2 = "0.10"
+# Async (for embedding API)
+tokio = { version = "1.0", features = ["full"] }
+reqwest = { version = "0.11", features = ["json"] }
+# Logging
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["json", "env-filter"] }
+# Parallel processing
+rayon = "1.8"
+# Memory mapping
+memmap2 = "0.9"
+# Binary serialization
+byteorder = "1.5"
+# Regular expressions
+regex = "1.10"
+# Date/time
+chrono = { version = "0.4", features = ["serde"] }
+# File operations
+fs_extra = "1.3"
+# Environment
+dotenvy = "0.15"
+# Tree-sitter for AST parsing
+# Tree-sitter for AST parsing
+
+# Tree-sitter for AST parsing
+tree-sitter = "0.20"
+tree-sitter-rust = "0.20"
+tree-sitter-typescript = "0.20"