claude-flow-novice 2.18.12 → 2.18.14

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

@@ -0,0 +1,37 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::io;
+use walkdir::{WalkDir, DirEntry};
+
+pub fn collect_files(root_dir: &Path, index_path: &Path) -> io::Result<Vec<PathBuf>> {
+    let mut files = Vec::new();
+    
+    for entry in WalkDir::new(root_dir)
+        .into_iter()
+        .filter_entry(|e| {
+            let path = e.path();
+            
+            // Skip the index file itself
+            if path == index_path {
+                return false;
+            }
+            
+            // Skip specific directories
+            if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
+                match name {
+                    "node_modules" | "target" | "dist" | "build" => return false,
+                    _ => {}
+                }
+            }
+            
+            true
+        })
+        .filter_map(|e| e.ok())
+    {
+        if entry.file_type().is_file() {
+            files.push(entry.path().to_path_buf());
+        }
+    }
+    
+    Ok(files)
+}

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

@@ -7,6 +7,7 @@ use serde_json::json;
 use crate::embeddings::EmbeddingsManager;
 use crate::search_engine::SearchEngine;
 use crate::sqlite_store::SqliteStore;
+use local_ruvector::paths::{get_ruvector_dir, get_v1_index_dir, get_database_path};
 
 pub struct InitCommand {
     project_dir: PathBuf,
@@ -30,8 +31,8 @@ impl InitCommand {
                               self.project_dir.display()));
         }
 
-        // Check if already initialized
-        let ruvector_dir = self.project_dir.join(".ruvector");
+        // Check if already initialized in centralized location
+        let ruvector_dir = get_ruvector_dir()?;
         if ruvector_dir.exists() && !self.force {
             eprintln!("⚠️  RuVector already initialized. Use --force to reinitialize.");
             return Err(anyhow!("Already initialized"));
@@ -42,19 +43,18 @@ impl InitCommand {
     }
 
     pub fn execute(&self) -> Result<()> {
-        info!("Initializing RuVector in: {}", self.project_dir.display());
-
-        let ruvector_dir = self.project_dir.join(".ruvector");
+        let ruvector_dir = get_ruvector_dir()?;
+        info!("Initializing centralized RuVector in: {}", ruvector_dir.display());
 
         // Remove existing directory if forcing
         if self.force && ruvector_dir.exists() {
             fs::remove_dir_all(&ruvector_dir)
-                .context("Failed to remove existing .ruvector directory")?;
+                .context("Failed to remove existing RuVector directory")?;
         }
 
         // Create directory structure
         fs::create_dir_all(&ruvector_dir)
-            .context("Failed to create .ruvector directory")?;
+            .context("Failed to create RuVector directory")?;
 
         // Create subdirectories
         fs::create_dir_all(ruvector_dir.join("embeddings"))?;
@@ -80,7 +80,8 @@ impl InitCommand {
     }
 
     fn create_config(&self) -> Result<()> {
-        let config_path = self.project_dir.join(".ruvector").join("config.json");
+        let ruvector_dir = get_ruvector_dir()?;
+        let config_path = ruvector_dir.join("config.json");
 
         let config = json!({
             "version": "1.0.0",
@@ -100,16 +101,20 @@ impl InitCommand {
     }
 
     fn initialize_database(&self) -> Result<()> {
-        let db_path = self.project_dir.join(".ruvector").join("index.db");
+        let db_path = get_database_path()?;
         let store = SqliteStore::new(&db_path)?;
         store.initialize()?;
 
-        debug!("Database initialized: {}", db_path.display());
+        // Initialize Schema V2 (entities, refs, type_usage, modules, entity_embeddings)
+        let conn = rusqlite::Connection::open(&db_path)?;
+        local_ruvector::schema_v2::SchemaV2::initialize(&conn)?;
+
+        debug!("Database initialized (V1 + V2 schemas): {}", db_path.display());
         Ok(())
     }
 
     fn initialize_embeddings(&self) -> Result<()> {
-        let embeddings_dir = self.project_dir.join(".ruvector");
+        let embeddings_dir = get_ruvector_dir()?;
         let _ = EmbeddingsManager::new(&embeddings_dir)?;
 
         debug!("Embeddings manager initialized");
@@ -124,4 +129,4 @@ impl InitCommand {
         debug!("Search engine initialized");
         Ok(())
     }
-}
+}

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

@@ -1,5 +1,9 @@
-use anyhow::{Result, anyhow};
+use anyhow::{Result, Context, anyhow};
 use std::path::{Path, PathBuf};
+use rusqlite::Connection;
+use tracing::{info, error};
+
+use crate::migration_tx::MigrationWithTx;
 
 #[derive(Debug, Clone)]
 pub enum SourceType {
@@ -40,6 +44,35 @@ impl MigrationCommand {
         }
     }
 
+    /// Execute migration with transaction support
+    pub fn execute_with_tx(&self) -> Result<()> {
+        let db_path = self.project_dir.join(".ruvector/index_v2.db");
+
+        // Ensure database directory exists
+        std::fs::create_dir_all(db_path.parent().unwrap())
+            .context("Failed to create database directory")?;
+
+        let mut conn = Connection::open(&db_path)
+            .context("Failed to open database for migration")?;
+
+        info!("Starting migration with transaction support");
+
+        // Use the transaction-aware migration
+        match self.source_type {
+            SourceType::RuVectorPython => {
+                MigrationWithTx::migrate_v1_to_v2_atomic(&mut conn)?;
+                MigrationWithTx::validate_migration(&mut conn)?;
+            }
+            _ => {
+                // For other sources, fall back to the original method
+                self.execute()?;
+            }
+        }
+
+        info!("Migration completed successfully");
+        Ok(())
+    }
+
     fn migrate_from_python(&self) -> Result<()> {
         println!("⚠️  Migration from Python RuVector not yet implemented");
         if self.dry_run {

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

@@ -1,18 +1,24 @@
 pub mod init;
 pub mod index;
+pub mod index_ast;
 pub mod query;
 pub mod stats;
 pub mod cleanup;
 pub mod migration;
 pub mod reset;
 pub mod export;
+pub mod find;
+pub mod refs;
 
 // Re-export the command structs only, not internal types
 pub use init::InitCommand;
 pub use index::IndexCommand;
+pub use index_ast::AstIndexCommand;
 pub use query::{QueryCommand, BatchQueryCommand};
 pub use stats::StatsCommand;
 pub use cleanup::CleanupCommand;
 pub use migration::MigrationCommand;
 pub use reset::ResetCommand;
 pub use export::{ExportCommand, ExportFormat};
+pub use find::FindCommand;
+pub use refs::RefsCommand;

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

@@ -62,7 +62,7 @@ impl QueryCommand {
         info!("Executing query: {}", self.config.query);
 
         // Load the search engine
-        let mut search_engine = self.search_engine.clone();
+        let mut search_engine = self.search_engine.duplicate()?;
         search_engine.load_or_create()?;
 
         // Perform search
@@ -170,7 +170,7 @@ impl BatchQueryCommand {
         info!("Executing batch queries from: {}", self.batch_file.display());
 
         // Load the search engine
-        let mut search_engine = self.search_engine.clone();
+        let mut search_engine = self.search_engine.duplicate()?;
         search_engine.load_or_create()?;
 
         // Read batch queries

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

@@ -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/src/embeddings.rs

@@ -1,24 +1,26 @@
 use anyhow::{Result, Context, anyhow};
-use ndarray::Array1;
 use serde::{Serialize, Deserialize};
 use std::path::Path;
-use std::collections::HashMap;
-use std::fs;
-use tracing::{info, debug};
+use std::env;
+use reqwest;
+use tokio;
+use tracing::{info, debug, warn, error};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct EmbeddingConfig {
     pub dimension: usize,
     pub model: String,
     pub batch_size: usize,
+    pub api_key: Option<String>,
 }
 
 impl Default for EmbeddingConfig {
     fn default() -> Self {
         Self {
             dimension: 1536,
-            model: "text-embedding-ada-002".to_string(),
+            model: "text-embedding-3-small".to_string(),
             batch_size: 100,
+            api_key: env::var("OPENAI_API_KEY").ok(),
         }
     }
 }
@@ -26,65 +28,112 @@ impl Default for EmbeddingConfig {
 #[derive(Debug, Clone)]
 pub struct EmbeddingsManager {
     config: EmbeddingConfig,
-    cache: HashMap<String, Array1<f32>>,
+    client: reqwest::Client,
+}
+
+#[derive(Debug, Serialize)]
+struct OpenAIRequest {
+    input: Vec<String>,
+    model: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct OpenAIResponse {
+    data: Vec<OpenAIEmbedding>,
+}
+
+#[derive(Debug, Deserialize)]
+struct OpenAIEmbedding {
+    embedding: Vec<f32>,
 }
 
 impl EmbeddingsManager {
     pub fn new(cache_dir: &Path) -> Result<Self> {
-        fs::create_dir_all(cache_dir)
+        std::fs::create_dir_all(cache_dir)
             .context("Failed to create embeddings cache directory")?;
 
         let config = EmbeddingConfig::default();
+        let client = reqwest::Client::new();
 
         Ok(Self {
             config,
-            cache: HashMap::new(),
+            client,
         })
     }
 
-    pub fn generate_embeddings(&self, texts: &[String]) -> Result<Vec<Vec<f32>>> {
-        debug!("Generating embeddings for {} texts", texts.len());
+    async fn call_openai_api(&self, texts: &[String]) -> Result<Vec<Vec<f32>>> {
+        let api_key = self.config.api_key.as_ref()
+            .ok_or_else(|| anyhow!("OpenAI API key not configured"))?;
+
+        let request = OpenAIRequest {
+            input: texts.to_vec(),
+            model: self.config.model.clone(),
+        };
+
+        let response = self.client
+            .post("https://api.openai.com/v1/embeddings")
+            .header("Authorization", format!("Bearer {}", api_key))
+            .header("Content-Type", "application/json")
+            .json(&request)
+            .send()
+            .await
+            .context("Failed to send request to OpenAI API")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let error_text = response.text().await.unwrap_or_default();
+            error!("OpenAI API error: {} - {}", status, error_text);
+            return Err(anyhow!("OpenAI API request failed: {}", status));
+        }
 
-        let mut embeddings = Vec::with_capacity(texts.len());
+        let openai_response: OpenAIResponse = response.json().await
+            .context("Failed to parse OpenAI API response")?;
 
-        for text in texts {
-            // Generate a simple dummy embedding for now
-            // In a real implementation, this would call an embedding API
-            let embedding = self.generate_dummy_embedding(text)?;
-            embeddings.push(embedding);
-        }
+        let embeddings: Vec<Vec<f32>> = openai_response.data
+            .into_iter()
+            .map(|emb| emb.embedding)
+            .collect();
 
-        info!("Generated {} embeddings", embeddings.len());
         Ok(embeddings)
     }
 
-    pub fn generate_embedding(&self, text: &str) -> Result<Vec<f32>> {
-        // Check cache first
-        if let Some(embedding) = self.cache.get(text) {
-            return Ok(embedding.to_vec());
+    pub fn generate_embeddings(&self, texts: &[String]) -> Result<Vec<Vec<f32>>> {
+        debug!("Generating embeddings for {} texts", texts.len());
+
+        if self.config.api_key.is_none() {
+            warn!("OpenAI API key not found, falling back to dummy embeddings");
+            let mut embeddings = Vec::with_capacity(texts.len());
+            for text in texts {
+                embeddings.push(self.generate_dummy_embedding(text));
+            }
+            info!("Generated {} dummy embeddings", embeddings.len());
+            return Ok(embeddings);
         }
 
-        // Generate new embedding
-        let embedding = self.generate_dummy_embedding(text)?;
-        
-        Ok(embedding)
+        let mut all_embeddings = Vec::with_capacity(texts.len());
+        let rt = tokio::runtime::Runtime::new()?;
+
+        for chunk in texts.chunks(self.config.batch_size) {
+            let embeddings = rt.block_on(self.call_openai_api(chunk))
+                .context("Failed to generate embeddings from OpenAI API")?;
+            all_embeddings.extend(embeddings);
+        }
+
+        info!("Generated {} embeddings", all_embeddings.len());
+        Ok(all_embeddings)
     }
 
-    fn generate_dummy_embedding(&self, text: &str) -> Result<Vec<f32>> {
-        // Generate a deterministic but pseudo-random embedding based on text
+    fn generate_dummy_embedding(&self, text: &str) -> Vec<f32> {
         let mut embedding = vec![0.0; self.config.dimension];
         
-        // Simple hash-based embedding generation
         let bytes = text.as_bytes();
         for (i, &byte) in bytes.iter().enumerate() {
             let pos = (i * 7) % self.config.dimension;
             embedding[pos] = ((byte as f32) / 255.0) * 2.0 - 1.0;
         }
 
-        // Apply some transformations to make it more realistic
         self.normalize_embedding(&mut embedding);
-
-        Ok(embedding)
+        embedding
     }
 
     fn normalize_embedding(&self, embedding: &mut [f32]) {
@@ -118,4 +167,4 @@ impl EmbeddingsManager {
             .map(|emb| self.compute_similarity(query, emb))
             .collect()
     }
-}
+}